codeep 2.11.1 → 2.12.0

package/dist/acp/session.js

@@ -90,8 +90,15 @@ export async function runAgentSession(opts) {
     const result = await runAgent(opts.prompt, projectContext, {
         abortSignal: opts.abortSignal,
         onChunk: (text) => { chunksEmitted++; opts.onChunk(text); },
-        onIteration: (_iteration, _message) => {
-            // Intentionally not forwarded — iteration count is internal detail
+        onIteration: (_iteration, message) => {
+            // The bare iteration counter is internal noise, but transient notices —
+            // API retry/backoff ("retrying in Ns") and context warnings (⚠) — are
+            // exactly what the user needs to see when a request stalls, otherwise
+            // the editor just shows an endless "Thinking…" spinner. Surface those
+            // (and only those) as a thought.
+            if (opts.onThought && /retry|⚠/i.test(message)) {
+                opts.onThought(message);
+            }
         },
         onThinking: (text) => {
             if (opts.onThought) {

package/dist/api/index.js

@@ -2,7 +2,7 @@ import * as http from 'node:http';
 import * as https from 'node:https';
 import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { withRetry, isNetworkError } from '../utils/retry.js';
-import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams } from '../config/providers.js';
+import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, reasoningParamsFor } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from '../utils/projectIntelligence.js';
 import { loadProjectRules } from '../utils/agent.js';
@@ -390,6 +390,7 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
         ...(stream ? { stream_options: { include_usage: true } } : {}),
         ...(omitTemperature ? {} : { temperature }),
         ...(useCompletionTokens ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens }),
+        ...reasoningParamsFor(providerId, model, config.get('reasoningEffort')),
         ...(providerId === 'openrouter' ? { usage: { include: true } } : {}),
         ...(openRouterProvider ? { provider: openRouterProvider } : {}),
     });
@@ -658,6 +659,7 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
                 // Fable 5 / Opus 4.7+ reject temperature with a 400 — omit it there
                 // (omission means API default on every Claude model).
                 ...(modelRejectsSamplingParams(model) ? {} : { temperature }),
+                ...reasoningParamsFor(providerId, model, config.get('reasoningEffort')),
                 stream,
                 ...cachedSystem,
             }),

package/dist/config/index.d.ts

@@ -52,6 +52,11 @@ interface ConfigSchema {
     migrationVersion: number;
     temperature: number;
     maxTokens: number;
+    /** Thinking / reasoning-effort tier sent with each request. 'auto' (default)
+     *  omits the param so each model uses its own default; low/medium/high/max are
+     *  clamped per provider+model by reasoningParamsFor() (config/providers.ts).
+     *  Only applied for models that expose a graded knob — set via `/thinking`. */
+    reasoningEffort: 'auto' | 'low' | 'medium' | 'high' | 'max';
     apiTimeout: number;
     rateLimitApi: number;
     rateLimitCommands: number;

package/dist/config/index.js

@@ -180,6 +180,7 @@ function createConfig() {
         currentSessionId: '',
         temperature: 0.7,
         maxTokens: 32768,
+        reasoningEffort: 'auto',
         apiTimeout: 60000,
         rateLimitApi: 10000,
         rateLimitCommands: 10000,

package/dist/config/providers.d.ts

@@ -74,3 +74,57 @@ export declare function modelRejectsSamplingParams(model: string): boolean;
  * Falls back to the requested value if no provider limit is set.
  */
 export declare function getEffectiveMaxTokens(providerId: string, requested: number): number;
+/**
+ * Unified, user-facing thinking-effort tiers (the `/thinking` setting).
+ *
+ *   'auto'  — omit the param entirely → each provider's own default.
+ *   low / medium / high / max — four explicit depth tiers.
+ *
+ * The four tiers are CONCEPTUAL. `reasoningParamsFor()` clamps each one to the
+ * nearest level the active provider+model actually accepts, so we never send a
+ * value that would 400 (e.g. Gemini rejects "medium"; OpenAI has no "max").
+ * The control is a pure DEPTH knob on models that already think — it never
+ * toggles thinking on/off, which keeps us clear of the reasoning_content-replay
+ * contract that DeepSeek/GLM impose when thinking mode is flipped.
+ */
+export type ReasoningTier = 'auto' | 'low' | 'medium' | 'high' | 'max';
+export declare const REASONING_TIERS: ReasoningTier[];
+/**
+ * Canonicalize a model id for capability matching: lowercase, drop any
+ * `vendor/` namespace (OpenRouter sends `anthropic/claude-opus-4.8`), and
+ * normalize `.` version separators to `-` (`glm-5.2` → `glm-5-2`,
+ * `claude-opus-4.8` → `claude-opus-4-8`). Mirrors macOS `ModelTuning.canonicalModelID`.
+ */
+export declare function canonicalModelId(model: string): string;
+/**
+ * Does this provider+model expose a GRADED thinking-effort control we can drive?
+ * Used to gate the `/thinking` UI — hidden entirely for models without one.
+ * Keep in lockstep with macOS `ModelTuning.reasoningEffortSupported`.
+ */
+export declare function modelSupportsReasoningEffort(providerId: string, model: string): boolean;
+/**
+ * Build the request-body fields that carry the chosen effort tier for the
+ * active provider+model+protocol. Returns `{}` for 'auto', unsupported
+ * models, or providers without a graded knob — so callers can spread it
+ * unconditionally. Keep in lockstep with macOS `ModelTuning.reasoningParams`.
+ */
+export declare function reasoningParamsFor(providerId: string, model: string, tier: ReasoningTier): Record<string, unknown>;
+/**
+ * The DISTINCT tiers a given provider+model actually exposes — used to build a
+ * per-model picker that only offers levels the model can tell apart (e.g.
+ * GLM-5.2/DeepSeek grade only high|max; Gemini via the OpenAI-compat layer only
+ * low|high). Always leads with 'auto'. `[]` for models with no graded knob.
+ *
+ * Kept in lockstep with `reasoningParamsFor` (the providers-test asserts every
+ * listed tier yields a DISTINCT param, so this can't silently drift). Mirrors
+ * macOS `ModelTuning.availableReasoningTiers`.
+ */
+export declare function availableReasoningTiers(providerId: string, model: string): ReasoningTier[];
+/**
+ * Map a (possibly out-of-range) tier to the tier this model actually distinguishes,
+ * for display — the chip + the checked menu row. The effort setting is global, so
+ * a tier picked on Opus ('low') may not exist on GLM-5.2; we show the level GLM
+ * will really run (its 'low' clamps to 'high'). Picks the available tier whose
+ * effective param equals the requested one. 'auto' (or unsupported) → 'auto'.
+ */
+export declare function resolveReasoningTier(providerId: string, model: string, tier: ReasoningTier): ReasoningTier;

package/dist/config/providers.js

@@ -19,9 +19,7 @@ export const PROVIDERS = {
         },
         models: [
             { id: 'glm-5.2', name: 'GLM-5.2', description: 'Latest GLM model, available to all users' },
-            { id: 'glm-5.1', name: 'GLM-5.1', description: 'Previous GLM model, available to all users' },
             { id: 'glm-5-turbo', name: 'GLM-5 Turbo', description: 'Fast GLM-5 variant, available to all users' },
-            { id: 'glm-5', name: 'GLM-5', description: 'Most capable GLM-5 model (Pro/Max plan only)' },
         ],
         defaultModel: 'glm-5.2',
         defaultProtocol: 'openai',
@@ -47,9 +45,7 @@ export const PROVIDERS = {
         },
         models: [
             { id: 'glm-5.2', name: 'GLM-5.2', description: 'Latest GLM model' },
-            { id: 'glm-5.1', name: 'GLM-5.1', description: 'Previous GLM model' },
             { id: 'glm-5-turbo', name: 'GLM-5 Turbo', description: 'Fast GLM-5 variant' },
-            { id: 'glm-5', name: 'GLM-5', description: 'Most capable GLM-5 model' },
         ],
         defaultModel: 'glm-5.2',
         defaultProtocol: 'openai',
@@ -75,9 +71,7 @@ export const PROVIDERS = {
         },
         models: [
             { id: 'glm-5.2', name: 'GLM-5.2', description: 'Latest GLM model, available to all users' },
-            { id: 'glm-5.1', name: 'GLM-5.1', description: 'Previous GLM model, available to all users' },
             { id: 'glm-5-turbo', name: 'GLM-5 Turbo', description: 'Fast GLM-5 variant, available to all users' },
-            { id: 'glm-5', name: 'GLM-5', description: 'Most capable GLM-5 model (Pro/Max plan only)' },
         ],
         defaultModel: 'glm-5.2',
         defaultProtocol: 'openai',
@@ -103,9 +97,7 @@ export const PROVIDERS = {
         },
         models: [
             { id: 'glm-5.2', name: 'GLM-5.2', description: 'Latest GLM model' },
-            { id: 'glm-5.1', name: 'GLM-5.1', description: 'Previous GLM model' },
             { id: 'glm-5-turbo', name: 'GLM-5 Turbo', description: 'Fast GLM-5 variant' },
-            { id: 'glm-5', name: 'GLM-5', description: 'Most capable GLM-5 model' },
         ],
         defaultModel: 'glm-5.2',
         defaultProtocol: 'openai',
@@ -225,7 +217,6 @@ export const PROVIDERS = {
             { id: 'gpt-5.5', name: 'GPT-5.5', description: 'Latest GPT model — best for coding' },
             { id: 'gpt-5.4', name: 'GPT-5.4', description: 'Previous generation GPT' },
             { id: 'gpt-5.4-mini', name: 'GPT-5.4 Mini', description: 'Faster and cheaper GPT-5.4' },
-            { id: 'gpt-5.4-nano', name: 'GPT-5.4 Nano', description: 'Most affordable, great for simple tasks' },
         ],
         defaultModel: 'gpt-5.5',
         defaultProtocol: 'openai',
@@ -247,7 +238,6 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'claude-fable-5', name: 'Claude Fable 5', description: 'Most powerful — new tier above Opus' },
             { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', description: 'Most capable Opus model' },
             { id: 'claude-sonnet-4-6', name: 'Claude Sonnet', description: 'Best balance of speed and intelligence' },
             { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku', description: 'Fastest and most affordable' },
@@ -472,3 +462,151 @@ export function getEffectiveMaxTokens(providerId, requested) {
         return requested;
     return Math.min(requested, provider.maxOutputTokens);
 }
+export const REASONING_TIERS = ['auto', 'low', 'medium', 'high', 'max'];
+/**
+ * Canonicalize a model id for capability matching: lowercase, drop any
+ * `vendor/` namespace (OpenRouter sends `anthropic/claude-opus-4.8`), and
+ * normalize `.` version separators to `-` (`glm-5.2` → `glm-5-2`,
+ * `claude-opus-4.8` → `claude-opus-4-8`). Mirrors macOS `ModelTuning.canonicalModelID`.
+ */
+export function canonicalModelId(model) {
+    let id = model.toLowerCase();
+    const slash = id.lastIndexOf('/');
+    if (slash !== -1)
+        id = id.slice(slash + 1);
+    return id.replace(/\./g, '-');
+}
+/** True when `id` equals `prefix` or starts with `prefix-` (catches dated variants). */
+function idMatches(id, prefix) {
+    return id === prefix || id.startsWith(`${prefix}-`);
+}
+/**
+ * Does this provider+model expose a GRADED thinking-effort control we can drive?
+ * Used to gate the `/thinking` UI — hidden entirely for models without one.
+ * Keep in lockstep with macOS `ModelTuning.reasoningEffortSupported`.
+ */
+export function modelSupportsReasoningEffort(providerId, model) {
+    const id = canonicalModelId(model);
+    switch (providerId) {
+        case 'anthropic':
+            // Effort is GA on Opus 4.5+, Sonnet 4.6, Fable 5 — NOT Haiku or Sonnet 4.5.
+            if (idMatches(id, 'claude-haiku-4-5') || idMatches(id, 'claude-sonnet-4-5'))
+                return false;
+            return /^claude-(opus-4-([5-9]|\d\d)|sonnet-4-6|fable-5)/.test(id);
+        case 'openai':
+            // GPT-5.x are reasoning models — reasoning_effort across the family (incl. mini).
+            return id.startsWith('gpt-5');
+        case 'google':
+            // Gemini 3.x thinking_level via the OpenAI-compat reasoning_effort mapping.
+            return id.startsWith('gemini-3');
+        case 'deepseek':
+            return id.startsWith('deepseek-v4');
+        case 'z.ai':
+        case 'z.ai-api':
+        case 'z.ai-cn':
+        case 'z.ai-cn-api':
+            // GLM-5.2 added graded High/Max effort. glm-5-turbo is a plain thinking
+            // toggle (no graded levels) so it stays out.
+            return idMatches(id, 'glm-5-2');
+        case 'openrouter':
+            // OpenRouter normalizes a unified `reasoning` field and silently ignores
+            // it for non-reasoning models, so the control is always safe to expose.
+            return true;
+        default:
+            // minimax (toggle only), ollama, custom — no graded depth knob.
+            return false;
+    }
+}
+/**
+ * Build the request-body fields that carry the chosen effort tier for the
+ * active provider+model+protocol. Returns `{}` for 'auto', unsupported
+ * models, or providers without a graded knob — so callers can spread it
+ * unconditionally. Keep in lockstep with macOS `ModelTuning.reasoningParams`.
+ */
+export function reasoningParamsFor(providerId, model, tier) {
+    // 'auto', or any unexpected value from an older/garbled config, → no param.
+    // (Guards against ever emitting e.g. `effort: undefined`, which could 400.)
+    if (tier === 'auto' || !REASONING_TIERS.includes(tier))
+        return {};
+    if (!modelSupportsReasoningEffort(providerId, model))
+        return {};
+    switch (providerId) {
+        case 'anthropic':
+            // low / medium / high / max — all valid on the capable Claude models.
+            return { output_config: { effort: tier } };
+        case 'openai':
+            // none/low/medium/high/xhigh — no "max"; map our Max → xhigh (the ceiling).
+            return { reasoning_effort: tier === 'max' ? 'xhigh' : tier };
+        case 'google':
+            // Gemini 3 (OpenAI-compat) accepts ONLY low/high — "medium" 400s.
+            return { reasoning_effort: tier === 'low' ? 'low' : 'high' };
+        case 'deepseek':
+        case 'z.ai':
+        case 'z.ai-api':
+        case 'z.ai-cn':
+        case 'z.ai-cn-api':
+            // Graded thinking depth: high (default) or max. Lower tiers collapse to high.
+            return { reasoning_effort: tier === 'max' ? 'max' : 'high' };
+        case 'openrouter':
+            // Unified reasoning object; no "max" effort → cap at high.
+            return { reasoning: { effort: tier === 'max' ? 'high' : tier } };
+        default:
+            return {};
+    }
+}
+/**
+ * The DISTINCT tiers a given provider+model actually exposes — used to build a
+ * per-model picker that only offers levels the model can tell apart (e.g.
+ * GLM-5.2/DeepSeek grade only high|max; Gemini via the OpenAI-compat layer only
+ * low|high). Always leads with 'auto'. `[]` for models with no graded knob.
+ *
+ * Kept in lockstep with `reasoningParamsFor` (the providers-test asserts every
+ * listed tier yields a DISTINCT param, so this can't silently drift). Mirrors
+ * macOS `ModelTuning.availableReasoningTiers`.
+ */
+export function availableReasoningTiers(providerId, model) {
+    if (!modelSupportsReasoningEffort(providerId, model))
+        return [];
+    switch (providerId) {
+        case 'anthropic':
+        case 'openai':
+            return ['auto', 'low', 'medium', 'high', 'max'];
+        case 'google':
+            // OpenAI-compat layer accepts only low/high — "medium" 400s.
+            return ['auto', 'low', 'high'];
+        case 'deepseek':
+        case 'z.ai':
+        case 'z.ai-api':
+        case 'z.ai-cn':
+        case 'z.ai-cn-api':
+            return ['auto', 'high', 'max'];
+        case 'openrouter':
+            return ['auto', 'low', 'medium', 'high'];
+        default:
+            return [];
+    }
+}
+/**
+ * Map a (possibly out-of-range) tier to the tier this model actually distinguishes,
+ * for display — the chip + the checked menu row. The effort setting is global, so
+ * a tier picked on Opus ('low') may not exist on GLM-5.2; we show the level GLM
+ * will really run (its 'low' clamps to 'high'). Picks the available tier whose
+ * effective param equals the requested one. 'auto' (or unsupported) → 'auto'.
+ */
+export function resolveReasoningTier(providerId, model, tier) {
+    if (tier === 'auto')
+        return 'auto';
+    const avail = availableReasoningTiers(providerId, model);
+    if (avail.length === 0)
+        return 'auto';
+    if (avail.includes(tier))
+        return tier;
+    const target = JSON.stringify(reasoningParamsFor(providerId, model, tier));
+    for (const t of avail) {
+        if (t === 'auto')
+            continue;
+        if (JSON.stringify(reasoningParamsFor(providerId, model, t)) === target)
+            return t;
+    }
+    return 'auto';
+}

package/dist/renderer/App.js

@@ -66,7 +66,7 @@ const COMMAND_DESCRIPTIONS = {
     'drop': 'Remove file from context',
     'multiline': 'Toggle multi-line input',
     'test': 'Generate/run tests',
-    'docs': 'Add documentation',
+    'docs': 'Open web docs for a command (e.g. /docs personality)',
     'refactor': 'Improve code quality',
     'fix': 'Debug and fix issues',
     'explain': 'Explain code',
@@ -123,6 +123,8 @@ const COMMAND_DESCRIPTIONS = {
     'sync': 'Sync learning preferences and profiles to codeep.dev',
     'telemetry': 'Show or toggle automatic cloud telemetry (on/off)',
     'keysync': 'Show or toggle syncing API keys to codeep.dev (on/off)',
+    'thinking': 'Set the thinking/reasoning-effort tier (auto/low/medium/high/max) for models that support it',
+    'effort': 'Alias for /thinking — set the reasoning-effort tier',
     // 2.0 — surfaced for `/` autocomplete; documented in /help too.
     'compact': 'Summarize older messages to free up context',
     'commands': 'List custom slash commands in .codeep/commands/*.md',
@@ -2312,6 +2314,14 @@ export class App {
             this.screen.write(leftX - 1, y, '·', fg.gray);
             leftX += 1;
         }
+        // Thinking-effort tier, right beside the model (the CLI twin of the Mac
+        // app's effort chip). Only present when set + supported — see getStatus.
+        if (status.reasoningEffort) {
+            this.screen.write(leftX, y, fg.yellow + status.reasoningEffort + style.reset);
+            leftX += status.reasoningEffort.length + 2;
+            this.screen.write(leftX - 1, y, '·', fg.gray);
+            leftX += 1;
+        }
         this.screen.write(leftX, y, msgCount, fg.gray);
         leftX += msgCount.length;
         if (tokenStr) {

package/dist/renderer/commands.js

@@ -8,7 +8,7 @@
 import { config, getCurrentProvider, getModelsForCurrentProvider, PROTOCOLS, LANGUAGES, setProvider, setApiKey, clearApiKey, getApiKey, isTelemetryEnabled, telemetryForcedOffByEnv, isKeySyncEnabled, keySyncForcedOffByEnv, saveSession, startNewSession, loadSession, listSessionsWithInfo, deleteSession, renameSession, setProjectPermission, saveProfile, loadProfile, applyProfile, listProfiles, deleteProfile, initializeAsProject, isManuallyInitializedProject, } from '../config/index.js';
 import { getProjectContext } from '../utils/project.js';
 import { getCurrentVersion } from '../utils/update.js';
-import { getProviderList, getProvider } from '../config/providers.js';
+import { getProviderList, getProvider, modelSupportsReasoningEffort, reasoningParamsFor, availableReasoningTiers, resolveReasoningTier, REASONING_TIERS } from '../config/providers.js';
 import { setProjectContext } from '../api/index.js';
 import { runSkill, runCommandChain } from './agentExecution.js';
 import { loadProjectIntelligence, saveProjectIntelligence } from '../utils/projectIntelligence.js';
@@ -303,6 +303,57 @@ export async function handleCommand(command, args, ctx) {
             ctx.app.addMessage({ role: 'system', content: kLines.join('\n') });
             break;
         }
+        case 'effort':
+        case 'thinking': {
+            const providerId = config.get('provider');
+            const model = config.get('model');
+            const supported = modelSupportsReasoningEffort(providerId, model);
+            // Tiers THIS model actually distinguishes (e.g. GLM-5.2 → auto/high/max).
+            const available = availableReasoningTiers(providerId, model);
+            const sub = args[0]?.toLowerCase();
+            if (sub && REASONING_TIERS.includes(sub)) {
+                config.set('reasoningEffort', sub);
+                if (sub === 'auto') {
+                    ctx.app.notify('Thinking effort: auto — each model uses its own default.');
+                }
+                else if (!supported) {
+                    ctx.app.notify(`Thinking effort set to "${sub}", but ${model} has no graded thinking control — it will be ignored until you switch to a model that does (e.g. Opus 4.8, GPT-5.x, Gemini 3, DeepSeek V4, GLM-5.2).`);
+                }
+                else {
+                    // Tell the user what THIS model will actually run (the tier may
+                    // collapse onto a level the model distinguishes, e.g. low→high on GLM).
+                    const resolved = resolveReasoningTier(providerId, model, sub);
+                    const note = resolved === sub ? '' : ` (${model} runs this as "${resolved}")`;
+                    ctx.app.notify(`Thinking effort: ${sub}${note} — sending ${JSON.stringify(reasoningParamsFor(providerId, model, sub))}.`);
+                }
+                break;
+            }
+            if (sub && sub !== 'status') {
+                const offer = available.length > 0 ? available : REASONING_TIERS;
+                ctx.app.notify(`Usage: /thinking ${offer.join(' · /thinking ')}`);
+                break;
+            }
+            const tier = (config.get('reasoningEffort') ?? 'auto');
+            const resolved = resolveReasoningTier(providerId, model, tier);
+            const tLines = ['## Thinking effort', ''];
+            tLines.push(`**Tier**       ${tier}${resolved !== tier && tier !== 'auto' ? ` → ${resolved} on this model` : ''}`);
+            tLines.push(`**Model**      ${model} (${providerId})`);
+            if (!supported) {
+                tLines.push('**Effective**  not sent — this model has no graded thinking control');
+            }
+            else if (tier === 'auto') {
+                tLines.push('**Effective**  model default (no param sent)');
+            }
+            else {
+                tLines.push(`**Effective**  ${JSON.stringify(reasoningParamsFor(providerId, model, tier))}`);
+            }
+            if (supported)
+                tLines.push(`**Available**  ${available.join(' · ')}`);
+            tLines.push('');
+            tLines.push('Sets how hard the model reasons. Each model offers only the levels it distinguishes (GLM-5.2 / DeepSeek → high · max; Gemini → low · high; Opus/Sonnet & GPT-5.x → the full set). The setting is global and clamps to the active model, so it never sends a value the API rejects. `/effort` is an alias.');
+            ctx.app.addMessage({ role: 'system', content: tLines.join('\n') });
+            break;
+        }
         case 'grant': {
             setProjectPermission(ctx.projectPath, true, true);
             ctx.setHasWriteAccess(true);
@@ -341,10 +392,12 @@ export async function handleCommand(command, args, ctx) {
             runAgentTask(args.join(' '), true, ctx, () => null, () => { });
             break;
         }
+        case 'd':
         case 'docs': {
             // Open per-command web docs in the system browser. Lets the inline
             // /help stay terse (single-line entries) while users who want the
-            // long story get one keystroke away from a real page.
+            // long story get one keystroke away from a real page. `/d` is the
+            // short alias.
             const cmd = (args[0] ?? '').toLowerCase().replace(/^\//, '');
             const KNOWN = {
                 personality: 'https://codeep.dev/docs/agent#personalities',
@@ -1504,8 +1557,6 @@ Format: use headers per category, only include categories where you found issues
         case 'commit':
         case 't':
         case 'test':
-        case 'd':
-        case 'docs':
         case 'r':
         case 'refactor':
         case 'f':

package/dist/renderer/components/Settings.js

@@ -26,6 +26,19 @@ export const SETTINGS = [
         max: 32768,
         step: 256,
     },
+    {
+        key: 'reasoningEffort',
+        label: 'Thinking Effort',
+        getValue: () => config.get('reasoningEffort') ?? 'auto',
+        type: 'select',
+        options: [
+            { value: 'auto', label: 'Auto (model default)' },
+            { value: 'low', label: 'Low' },
+            { value: 'medium', label: 'Medium' },
+            { value: 'high', label: 'High' },
+            { value: 'max', label: 'Max' },
+        ],
+    },
     {
         key: 'apiTimeout',
         label: 'API Timeout (ms)',

package/dist/renderer/components/Status.d.ts

@@ -7,6 +7,9 @@ export interface StatusInfo {
     provider: string;
     model: string;
     agentMode: string;
+    /** Thinking-effort tier to show beside the model (e.g. "max") — only set
+     *  when non-auto AND the active model supports a graded knob; undefined hides it. */
+    reasoningEffort?: string;
     projectPath: string;
     hasWriteAccess: boolean;
     sessionId: string;

package/dist/renderer/main.js

@@ -15,7 +15,7 @@ import { getZaiVisionConfig, getMinimaxMcpConfig, callZaiVisionApi, callMinimaxA
 import { config, loadApiKey, loadAllApiKeys, getCurrentProvider, autoSaveSession, startNewSession, getCurrentSessionId, loadSession, listSessionsWithInfo, deleteSession, hasReadPermission, hasWritePermission, setProjectPermission, initializeAsProject, isManuallyInitializedProject, setApiKey, setProvider, getGithubId, } from '../config/index.js';
 import { isProjectDirectory, getProjectContext, } from '../utils/project.js';
 import { getCurrentVersion, checkForUpdates, getUpdateInstructions } from '../utils/update.js';
-import { getProviderList, isNoApiKeyProvider } from '../config/providers.js';
+import { getProviderList, isNoApiKeyProvider, resolveReasoningTier } from '../config/providers.js';
 import { getSessionStats, getCostBreakdown } from '../utils/tokenTracker.js';
 import { isGitRepository } from '../utils/git.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
@@ -73,11 +73,17 @@ function getStatus() {
     const providers = getProviderList();
     const providerInfo = providers.find(p => p.id === provider.id);
     const stats = getSessionStats();
+    // Show the thinking-effort tier beside the model. Resolve the (global) tier
+    // to what THIS model actually runs — e.g. a global 'low' shows as 'high' on
+    // GLM-5.2, which only grades high|max. 'auto'/unsupported → hidden.
+    const resolved = resolveReasoningTier(provider.id, config.get('model'), config.get('reasoningEffort'));
+    const reasoningEffort = resolved !== 'auto' ? resolved : undefined;
     return {
         version: getCurrentVersion(),
         provider: providerInfo?.name || 'Unknown',
         model: config.get('model'),
         agentMode: config.get('agentMode') || 'off',
+        reasoningEffort,
         projectPath,
         hasWriteAccess,
         sessionId,

package/dist/utils/agentChat.js

@@ -16,8 +16,9 @@ import { join } from 'path';
 import { createHash } from 'crypto';
 import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from './projectIntelligence.js';
+import { formatCommandIndex } from './commandIndex.js';
 import { syncProgress, generateProjectId } from './codeepCloud.js';
-import { getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, isNoApiKeyProvider } from '../config/providers.js';
+import { getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, isNoApiKeyProvider, reasoningParamsFor } from '../config/providers.js';
 import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker.js';
 import { parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing.js';
 import { formatToolDefinitions, getOpenAITools, getAnthropicTools } from './tools.js';
@@ -281,6 +282,16 @@ export function getAgentSystemPrompt(projectContext) {
 - Keep working until the task is actually finished. If you still have work to do, CALL A TOOL — don't just narrate. If you're done, reply with a short summary and no tool calls.
 - Don't ask permission for routine work; the user already launched the agent.
 
+## About Codeep
+Codeep is an open-source, terminal-native AI coding agent — also a native macOS app and a VS Code / Zed extension (over ACP). Beyond the file/command tools above, the user can extend you through Codeep features:
+- Skills — reusable workflow bundles (browse/add/run with \`/skills\`)
+- MCP — connect external tools & data, e.g. Postgres, GitHub, a browser, the iOS simulator (\`/mcp\`)
+- Sub-agents — delegate focused subtasks (\`/agents\`)
+- Personalities — change your working style (\`/personality\`)
+- A dashboard at codeep.dev for synced sessions, usage & cost
+When the user asks what you can do, or a task maps to one of these, point them at the right slash-command:
+${formatCommandIndex()}
+
 ## Codeep App Storage (your own metadata)
 This project uses Codeep. The following paths are Codeep's internal state — **read** them if you need context about prior sessions, but do not edit them manually during a task:
 - \`${root}/.codeep/intelligence.json\` — cached project analysis (structure, frameworks, CI/CD, conventions). Refresh via \`/scan\`.
@@ -360,6 +371,8 @@ additionalTools) {
         // Provider-level guard (OpenAI GPT-5+) OR model-level guard — Anthropic's
         // Fable 5 / Opus 4.7+ reject temperature with a 400; omission is safe.
         const tempParam = (requiresDefaultTemperature(providerId) || modelRejectsSamplingParams(model)) ? {} : { temperature: config.get('temperature') };
+        // Thinking-effort tier → provider-shaped param ({} for 'auto'/unsupported).
+        const reasoningParam = reasoningParamsFor(providerId, model, config.get('reasoningEffort'));
         if (protocol === 'openai') {
             const maxTok = getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384));
             const tokParam = usesMaxCompletionTokens(providerId) ? { max_completion_tokens: maxTok } : { max_tokens: maxTok };
@@ -410,7 +423,7 @@ additionalTools) {
             body = {
                 model, messages: [{ role: 'system', content: systemPrompt }, ...messages],
                 tools: getOpenAITools(additionalTools), tool_choice: 'auto', stream: useStreaming,
-                ...tempParam, ...tokParam,
+                ...tempParam, ...tokParam, ...reasoningParam,
                 ...(useStreaming && providerId === 'openai' ? { stream_options: { include_usage: true } } : {}),
                 ...openRouterExtras,
             };
@@ -436,7 +449,7 @@ additionalTools) {
                 system: [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }],
                 messages,
                 tools: cachedTools, stream: useStreaming,
-                ...tempParam, max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
+                ...tempParam, ...reasoningParam, max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
             };
         }
         const response = await fetch(endpoint, {
@@ -554,13 +567,15 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
         // Provider-level guard (OpenAI GPT-5+) OR model-level guard — Anthropic's
         // Fable 5 / Opus 4.7+ reject temperature with a 400; omission is safe.
         const tempParam = (requiresDefaultTemperature(providerId) || modelRejectsSamplingParams(model)) ? {} : { temperature: config.get('temperature') };
+        // Thinking-effort tier → provider-shaped param ({} for 'auto'/unsupported).
+        const reasoningParam = reasoningParamsFor(providerId, model, config.get('reasoningEffort'));
         if (protocol === 'openai') {
             const maxTok = getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384));
             const tokParam = usesMaxCompletionTokens(providerId) ? { max_completion_tokens: maxTok } : { max_tokens: maxTok };
             endpoint = `${baseUrl}/chat/completions`;
             body = {
                 model, messages: [{ role: 'system', content: fallbackPrompt }, ...messages],
-                stream: Boolean(onChunk), ...tempParam, ...tokParam,
+                stream: Boolean(onChunk), ...tempParam, ...tokParam, ...reasoningParam,
             };
         }
         else {
@@ -577,7 +592,7 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
                     { role: 'assistant', content: 'Understood. I will use the tools as specified.' },
                     ...messages,
                 ],
-                stream: Boolean(onChunk), ...tempParam,
+                stream: Boolean(onChunk), ...tempParam, ...reasoningParam,
                 max_tokens: getEffectiveMaxTokens(providerId, Math.max(config.get('maxTokens'), 16384)),
             };
         }

package/dist/utils/commandIndex.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Curated, agent-facing index of the most useful Codeep slash-commands.
+ *
+ * Injected into the agent's system prompt (see `getAgentSystemPrompt`) so the
+ * model knows these exist and can point the user at the right one. Deliberately
+ * a CURATED subset — not the full ~60-command registry in
+ * `renderer/commands.ts` — to keep the prompt small; every entry here must be
+ * a real command. Single source for this list so it doesn't drift across the
+ * places that describe Codeep to the model.
+ */
+export declare const COMMAND_INDEX: {
+    cmd: string;
+    desc: string;
+}[];
+/** Render the index as Markdown bullets for the system prompt. */
+export declare function formatCommandIndex(): string;

package/dist/utils/commandIndex.js

@@ -0,0 +1,29 @@
+/**
+ * Curated, agent-facing index of the most useful Codeep slash-commands.
+ *
+ * Injected into the agent's system prompt (see `getAgentSystemPrompt`) so the
+ * model knows these exist and can point the user at the right one. Deliberately
+ * a CURATED subset — not the full ~60-command registry in
+ * `renderer/commands.ts` — to keep the prompt small; every entry here must be
+ * a real command. Single source for this list so it doesn't drift across the
+ * places that describe Codeep to the model.
+ */
+export const COMMAND_INDEX = [
+    { cmd: '/scan', desc: 'analyze the project (structure, frameworks, conventions) into .codeep/intelligence.json' },
+    { cmd: '/plan', desc: 'plan a task before executing it (plan mode)' },
+    { cmd: '/skills', desc: 'browse, add, or run reusable skill bundles' },
+    { cmd: '/mcp', desc: 'connect external tools & data via MCP servers (Postgres, GitHub, a browser, the iOS simulator…)' },
+    { cmd: '/agents', desc: 'manage sub-agents you can delegate focused subtasks to' },
+    { cmd: '/personality', desc: 'switch the agent persona / working style' },
+    { cmd: '/review', desc: 'code-review the current changes' },
+    { cmd: '/commit', desc: 'write a commit message from the current diff' },
+    { cmd: '/pr', desc: 'open a pull request' },
+    { cmd: '/checkpoint', desc: 'save a restore point (/rewind rolls back to it)' },
+    { cmd: '/memory', desc: 'add or list project memory notes the agent remembers' },
+    { cmd: '/cost', desc: 'show token usage and estimated cost for the session' },
+    { cmd: '/settings', desc: 'change models, providers, confirmation policy, and limits' },
+];
+/** Render the index as Markdown bullets for the system prompt. */
+export function formatCommandIndex() {
+    return COMMAND_INDEX.map(c => `- \`${c.cmd}\` — ${c.desc}`).join('\n');
+}

package/dist/utils/mcpMarketplace.d.ts

@@ -9,7 +9,9 @@
  *   - Each entry's `args` should be the **invocation-without-runtime-args**
  *     so `/mcp install` can prompt for the things that vary per user
  *     (paths, tokens, etc.) via `argHints`.
- *   - Prefer official `@modelcontextprotocol/*` packages over third-party.
+ *   - Prefer official `@modelcontextprotocol/*` packages; well-maintained
+ *     third-party servers are fine when they're the de-facto standard for
+ *     their niche (e.g. Playwright for browsers, the iOS-simulator servers).
  */
 import type { McpServer } from '../acp/protocol.js';
 export interface MarketplaceEntry {

package/dist/utils/mcpMarketplace.js

@@ -9,7 +9,9 @@
  *   - Each entry's `args` should be the **invocation-without-runtime-args**
  *     so `/mcp install` can prompt for the things that vary per user
  *     (paths, tokens, etc.) via `argHints`.
- *   - Prefer official `@modelcontextprotocol/*` packages over third-party.
+ *   - Prefer official `@modelcontextprotocol/*` packages; well-maintained
+ *     third-party servers are fine when they're the de-facto standard for
+ *     their niche (e.g. Playwright for browsers, the iOS-simulator servers).
  */
 export const MCP_MARKETPLACE = [
     {
@@ -116,11 +118,25 @@ export const MCP_MARKETPLACE = [
         url: 'https://github.com/modelcontextprotocol/servers/tree/main/src/time',
     },
     {
-        id: 'puppeteer',
-        name: 'Puppeteer (browser)',
-        description: 'Headless Chromium for navigating, screenshotting, and scraping pages.',
-        server: { command: 'npx', args: ['-y', '@modelcontextprotocol/server-puppeteer'] },
-        url: 'https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer',
+        id: 'playwright',
+        name: 'Playwright (browser)',
+        description: 'Drive a real browser — navigate, click, fill, screenshot, and scrape — via Microsoft Playwright. The de-facto browser-automation MCP (supersedes Puppeteer).',
+        server: { command: 'npx', args: ['-y', '@playwright/mcp@latest'] },
+        url: 'https://github.com/microsoft/playwright-mcp',
+    },
+    {
+        id: 'ios-simulator',
+        name: 'iOS Simulator',
+        description: 'Drive the iOS Simulator — tap, type, swipe, screenshot, record, install & launch apps. macOS only; needs Xcode + idb (`brew install facebook/fb/idb-companion`).',
+        server: { command: 'npx', args: ['-y', 'ios-simulator-mcp'] },
+        url: 'https://github.com/joshuayoes/ios-simulator-mcp',
+    },
+    {
+        id: 'mobile',
+        name: 'Mobile (iOS + Android)',
+        description: 'UI automation for end-to-end mobile testing across iOS simulators/devices and Android. macOS needs Xcode command-line tools.',
+        server: { command: 'npx', args: ['-y', '@mobilenext/mobile-mcp@latest'] },
+        url: 'https://github.com/mobile-next/mobile-mcp',
     },
 ];
 export function findMarketplaceEntry(id) {

package/dist/utils/tokenTracker.js

@@ -8,16 +8,12 @@
 const MODEL_CONTEXT_WINDOWS = {
     // Z.AI / ZhipuAI
     'glm-5.2': 200_000,
-    'glm-5.1': 131_072,
-    'glm-5': 80_000,
     'glm-5-turbo': 202_752,
     // OpenAI
     'gpt-5.5': 1_200_000,
     'gpt-5.4': 1_050_000,
     'gpt-5.4-mini': 400_000,
-    'gpt-5.4-nano': 400_000,
     // Anthropic
-    'claude-fable-5': 1_000_000,
     'claude-opus-4-8': 1_000_000,
     'claude-sonnet-4-6': 1_000_000,
     'claude-haiku-4-5-20251001': 200_000,
@@ -48,16 +44,12 @@ const MODEL_PRICING = {
     // Note: on the GLM Coding Plan (the default `z.ai` provider) billing is a flat
     // subscription, so this only affects the pay-per-use estimate.
     'glm-5.2': { inputPer1M: 1.00, outputPer1M: 3.20 },
-    'glm-5.1': { inputPer1M: 1.00, outputPer1M: 3.20 },
-    'glm-5': { inputPer1M: 0.72, outputPer1M: 2.30 },
     'glm-5-turbo': { inputPer1M: 1.20, outputPer1M: 4.00 },
     // OpenAI
     'gpt-5.5': { inputPer1M: 5.00, outputPer1M: 30.00 },
     'gpt-5.4': { inputPer1M: 2.50, outputPer1M: 15.00 },
     'gpt-5.4-mini': { inputPer1M: 0.75, outputPer1M: 4.50 },
-    'gpt-5.4-nano': { inputPer1M: 0.20, outputPer1M: 1.25 },
     // Anthropic
-    'claude-fable-5': { inputPer1M: 10.00, outputPer1M: 50.00 },
     'claude-opus-4-8': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-sonnet-4-6': { inputPer1M: 3.00, outputPer1M: 15.00 },
     'claude-haiku-4-5-20251001': { inputPer1M: 1.00, outputPer1M: 5.00 },

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.11.1";
+export declare const VERSION = "2.12.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 // AUTO-GENERATED by scripts/gen-version.js — do not edit by hand.
 // Baked from package.json at build time so the bun-compiled binary reports
 // the right version (it has no package.json on disk to read at runtime).
-export const VERSION = '2.11.1';
+export const VERSION = '2.12.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.11.1",
+  "version": "2.12.0",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",