micro-models-agent 0.54.1 → 0.55.1

package/dist/main.js

@@ -2356,6 +2356,12 @@ var init_defaults = __esm(() => {
       checkOnStart: true,
       autoInstall: true,
       intervalMs: 0
+    },
+    reasoning: {
+      mode: "auto",
+      min: "low",
+      max: "high",
+      overrideCooldown: 5
     }
   };
 });
@@ -2416,6 +2422,7 @@ The path was joined onto the working directory because it does not exist as give
     "error.llm_stream_idle_toolcall": 'LLM stream stalled after a tool_call started — no data for {timeout}ms. The provider most likely buffers SSE instead of streaming tool-call argument deltas (seen with LM Studio). Raise "retry.noDataTimeoutMs" in ~/.mma/config.json (restart required)',
     "error.llm_truncated": 'Response hit the completion token limit ({tokens}) and was cut off before any content arrived. Split the task into smaller outputs or raise "maxCompletionTokens" in the config',
     "error.llm_truncated_toolcall": 'Response hit the completion token limit ({tokens}) in the middle of a tool_call — its arguments were cut off. Write the file in smaller chunks (several write_file/edit_file calls) or raise "maxCompletionTokens" in the config',
+    "error.llm_provider_stream_error": "Provider returned an error mid-stream: {error}",
     "error.llm_timeout": "LLM request timed out ({timeout}ms)",
     "env.runtime_node": "Running under Node (v{version}) — clipboard image paste, subagent performance and LSP spawn on Windows degrade. Install Bun (https://bun.sh) for full features.",
     "env.runtime_old": "Runtime version {version} is below the required engines {engine}.",
@@ -2708,6 +2715,7 @@ Available commands:`,
     "cli.no_agents_md": "Disable loading AGENTS.md files into system prompt",
     "cli.dir": "Working directory for the agent (defaults to current directory)",
     "cli.exit_on_complete": "Exit immediately when the task is done; interactive tools (question/approve) fail fast instead of blocking on stdin",
+    "cli.reasoning_level": "Set reasoning effort level (auto|none|low|medium|high|max)",
     "cli.json": "Output the result as JSON (single-run mode)",
     "cli.security.description": "Manage security settings",
     "cli.security.status": "Show current security configuration",
@@ -2766,7 +2774,9 @@ Available commands:`,
     "repl.config": "Show current configuration",
     "repl.config_usage": "Usage: /config",
     "repl.reasoning": "Toggle showing model reasoning/thinking",
-    "repl.reasoning_usage": "Usage: /reasoning",
+    "repl.reasoning_usage": "Usage: /reasoning [auto|none|low|medium|high|max]",
+    "repl.reasoning_level_set": "Reasoning level set to: {level}",
+    "repl.reasoning_invalid_level": "Invalid level '{level}'. Valid: {valid}",
     "repl.status": "Show agent status",
     "repl.status_usage": "Usage: /status",
     "repl.plugins": "List loaded plugins",
@@ -3067,6 +3077,15 @@ Apply a matching solution from these results. If none is relevant — do NOT rep
     "tools.enable_added": "Enabled tool tags: {tags}. Available tools now: {tools}",
     "tools.hidden_header": "Additional tools (enable on demand via enable_tools or route to subagent tool_tags):",
     "tool.friendly.enable_tools": "Enable tools",
+    "tool.friendly.set_thinking": "Set reasoning level",
+    "tool.thinking_set": "Reasoning level: {level} ({reason})",
+    "tool.thinking_set_clamped": "Reasoning level: {level} (clamped from request, {reason})",
+    "tool.thinking_cooldown": "Reasoning override deferred ({remaining} iterations until available). Current: {current}",
+    "tool.thinking_invalid_level": "Invalid reasoning level: {level}. Use: none, low, high, max",
+    "reasoning.probe_failed": "Reasoning effort mechanism not supported by this backend. Dynamic control disabled.",
+    "reasoning.mode_set": "Reasoning mode: {mode}",
+    "reasoning.current": "Reasoning: {level} ({mode})",
+    "reasoning.invalid_mode": "Invalid reasoning mode: {mode}. Use: auto, default, none, low, medium, high, max",
     "cli.provider_base_hint": "Base URL set to: {baseUrl}",
     "cli.add_provider": "Add a provider to the config",
     "cli.provider_no_url": 'No base URL for provider "{name}". Pass --url.',
@@ -3148,6 +3167,7 @@ var init_ru = __esm(() => {
     "error.llm_stream_idle_toolcall": 'Поток LLM завис после начала tool_call — нет данных {timeout}мс. Скорее всего провайдер буферизирует SSE вместо потоковой передачи аргументов tool_call (наблюдается в LM Studio). Увеличьте "retry.noDataTimeoutMs" в ~/.mma/config.json (нужен рестарт)',
     "error.llm_truncated": 'Ответ упёрся в лимит токенов генерации ({tokens}) и был обрезан до какого-либо содержимого. Разбейте задачу на меньшие порции вывода или увеличьте "maxCompletionTokens" в конфиге',
     "error.llm_truncated_toolcall": 'Ответ упёрся в лимит токенов генерации ({tokens}) посреди tool_call — его аргументы обрезаны. Пишите файл частями (несколько вызовов write_file/edit_file) или увеличьте "maxCompletionTokens" в конфиге',
+    "error.llm_provider_stream_error": "Провайдер вернул ошибку посреди стрима: {error}",
     "error.llm_timeout": "Время запроса LLM истекло ({timeout}мс)",
     "env.runtime_node": "Запущено под Node (v{version}) — вставка изображений из буфера и LSP на Windows работают урезанно. Установите Bun (https://bun.sh) для полного функционала.",
     "env.runtime_old": "Версия рантайма {version} ниже требуемой engines {engine}.",
@@ -3435,6 +3455,7 @@ var init_ru = __esm(() => {
     "cli.no_agents_md": "Отключить загрузку AGENTS.md в системный промпт",
     "cli.dir": "Рабочая директория агента (по умолчанию — текущая)",
     "cli.exit_on_complete": "Завершить сразу после выполнения задачи; интерактивные тулзы (question/approve) не блокируют stdin, а возвращают ошибку",
+    "cli.reasoning_level": "Установить уровень рассуждений (auto|none|low|medium|high|max)",
     "cli.json": "Вывести результат в формате JSON (режим однократного запуска)",
     "cli.security.description": "Управление настройками безопасности",
     "cli.security.status": "Показать текущую конфигурацию безопасности",
@@ -3493,7 +3514,9 @@ var init_ru = __esm(() => {
     "repl.config": "Показать текущую конфигурацию",
     "repl.config_usage": "Использование: /config",
     "repl.reasoning": "Переключить показ рассуждений модели",
-    "repl.reasoning_usage": "Использование: /reasoning",
+    "repl.reasoning_usage": "Использование: /reasoning [auto|none|low|medium|high|max]",
+    "repl.reasoning_level_set": "Уровень рассуждений установлен: {level}",
+    "repl.reasoning_invalid_level": "Неверный уровень '{level}'. Допустимые: {valid}",
     "repl.status": "Показать статус агента",
     "repl.status_usage": "Использование: /status",
     "repl.plugins": "Список загруженных плагинов",
@@ -3801,6 +3824,15 @@ var init_ru = __esm(() => {
     "tools.enable_added": "Включены теги тулов: {tags}. Теперь доступны тулы: {tools}",
     "tools.hidden_header": "Дополнительные тулы (включите по требованию через enable_tools или маршрутизируйте через subagent tool_tags):",
     "tool.friendly.enable_tools": "Включить тулы",
+    "tool.friendly.set_thinking": "Уровень рассуждений",
+    "tool.thinking_set": "Уровень рассуждений: {level} ({reason})",
+    "tool.thinking_set_clamped": "Уровень рассуждений: {level} (ограничен конфигом, {reason})",
+    "tool.thinking_cooldown": "Override отложен ({remaining} итераций до доступа). Текущий: {current}",
+    "tool.thinking_invalid_level": "Неверный уровень рассуждений: {level}. Допустимые: none, low, high, max",
+    "reasoning.probe_failed": "Бэкенд не поддерживает управление reasoning effort. Динамическое управление отключено.",
+    "reasoning.mode_set": "Режим рассуждений: {mode}",
+    "reasoning.current": "Рассуждения: {level} ({mode})",
+    "reasoning.invalid_mode": "Неверный режим рассуждений: {mode}. Допустимые: auto, default, none, low, medium, high, max",
     "cli.provider_base_hint": "Базовый URL установлен: {baseUrl}",
     "cli.add_provider": "Добавить провайдера в конфиг",
     "cli.provider_no_url": 'Нет базового URL для провайдера "{name}". Укажите --url.',
@@ -4293,7 +4325,8 @@ var init_domains = __esm(() => {
       "autoPlan",
       "showReasoning",
       "logLevel",
-      "locale"
+      "locale",
+      "reasoning"
     ],
     provider: ["provider", "orchestrator", "retry", "pricing"],
     moe: ["moe", "experts"],
@@ -5507,8 +5540,14 @@ function buildRequestBody(opts) {
   };
   if (opts.maxTokens !== undefined)
     body.max_tokens = opts.maxTokens;
-  if (opts.reasoningEffort) {
-    body.reasoning_effort = opts.reasoningEffort;
+  const strategy = opts.reasoningStrategy ?? "openai-effort";
+  const level = opts.reasoningEffort;
+  if (strategy === "openai-effort" && level && level !== "default") {
+    body.reasoning_effort = level;
+  } else if (strategy === "template-kwarg") {
+    body.chat_template_kwargs = { enable_thinking: level !== "none" };
+  } else if (strategy === "prompt-tag" && level && level !== "default") {
+    body.reasoning_effort = level;
   }
   if (opts.tools && opts.tools.length > 0) {
     body.tools = opts.tools.map((t2) => ({
@@ -5531,6 +5570,7 @@ class OpenAICompatProvider {
   tokenCounter;
   retryConfig;
   rateLimiter;
+  debug;
   constructor(config) {
     this.config = config;
     this.model = config.model;
@@ -5544,13 +5584,18 @@ class OpenAICompatProvider {
       noDataTimeoutMs: 180000
     };
     this.rateLimiter = createRateLimiter(config.rateLimits);
+    this.debug = config.logger ? config.logger.debug.bind(config.logger) : null;
   }
   async* chat(messages, tools, signal, options) {
     if (!this.rateLimiter.canMakeRequest()) {
       throw new Error(`Rate limit exceeded: ${this.rateLimiter.getConfig().maxRequestsPerMinute} requests per minute`);
     }
     this.rateLimiter.recordRequest();
-    const streamResult = this.doStream(messages, tools, signal, options);
+    let effectiveMessages = messages;
+    if (options?.reasoningStrategy === "prompt-tag" && options?.reasoningEffort === "none") {
+      effectiveMessages = this.applyPromptTag(messages, "/no_think");
+    }
+    const streamResult = this.doStream(effectiveMessages, tools, signal, options);
     let hasToolCall = false;
     let hasText = false;
     for await (const chunk of streamResult) {
@@ -5561,12 +5606,31 @@ class OpenAICompatProvider {
       yield chunk;
     }
     if (!hasToolCall && !hasText) {
-      const fallback = await this.doNonStreaming(messages, tools, signal, options);
+      this.debug?.("LLM streaming produced no text/tool_call — falling back to non-streaming");
+      const fallback = await this.doNonStreaming(effectiveMessages, tools, signal, options);
+      this.debug?.("LLM non-streaming fallback result", { chunks: fallback.length });
       for (const chunk of fallback) {
         yield chunk;
       }
     }
   }
+  applyPromptTag(messages, tag) {
+    const copy = [...messages];
+    for (let i = copy.length - 1;i >= 0; i--) {
+      if (copy[i].role === "user") {
+        const msg = { ...copy[i] };
+        if (typeof msg.content === "string") {
+          msg.content = msg.content + `
+` + tag;
+        } else {
+          msg.content = [...msg.content, { type: "text", text: tag }];
+        }
+        copy[i] = msg;
+        break;
+      }
+    }
+    return copy;
+  }
   async* doStream(messages, tools, signal, options) {
     const { baseDelay, maxDelay, maxStreamRetries, noDataTimeoutMs } = this.retryConfig;
     const streamRetries = maxStreamRetries ?? 2;
@@ -5601,7 +5665,18 @@ class OpenAICompatProvider {
       tools,
       stream: true,
       maxTokens,
-      reasoningEffort: options?.reasoningEffort
+      reasoningEffort: options?.reasoningEffort,
+      reasoningStrategy: options?.reasoningStrategy
+    });
+    this.debug?.("LLM stream request", {
+      baseUrl: this.config.baseUrl,
+      model: this.model,
+      stream: true,
+      maxTokens,
+      toolsCount: tools?.length ?? 0,
+      reasoningEffort: options?.reasoningEffort,
+      reasoningStrategy: options?.reasoningStrategy,
+      messagesCount: messages.length
     });
     const { headers, abortSignal, cleanup, isTimeout, flagTimeout, controller } = this.buildRequestSetup(signal);
     let response;
@@ -5630,6 +5705,11 @@ class OpenAICompatProvider {
       err.llmTerminal = true;
       throw err;
     }
+    const contentType = response.headers?.get?.("content-type") ?? "";
+    this.debug?.("LLM stream response headers", {
+      status: response.status,
+      contentType
+    });
     const reader = response.body?.getReader();
     if (!reader) {
       cleanup();
@@ -5639,6 +5719,10 @@ class OpenAICompatProvider {
     let buffer = "";
     const toolCallAccs = new Map;
     let sawToolCallStart = false;
+    let nonDataLines = 0;
+    const nonDataSamples = [];
+    let parsedChunks = 0;
+    let midStreamError = null;
     let usage;
     let sawDone = false;
     let lastFinishReason;
@@ -5673,15 +5757,24 @@ class OpenAICompatProvider {
         buffer = lines.pop() || "";
         for (const line of lines) {
           const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith("data: "))
-            continue;
-          const data = trimmed.slice(6);
-          if (data === "[DONE]") {
-            sawDone = true;
+          if (!trimmed)
             continue;
+          let data;
+          if (trimmed.startsWith("data: ")) {
+            data = trimmed.slice(6);
+            if (data === "[DONE]") {
+              sawDone = true;
+              continue;
+            }
+          } else {
+            nonDataLines++;
+            if (nonDataSamples.length < 5)
+              nonDataSamples.push(trimmed.slice(0, 200));
+            data = trimmed;
           }
           try {
             const parsed = JSON.parse(data);
+            parsedChunks++;
             const choice = parsed.choices?.[0];
             if (!choice) {
               if (parsed.usage) {
@@ -5690,56 +5783,71 @@ class OpenAICompatProvider {
                   completionTokens: parsed.usage.completion_tokens ?? 0,
                   totalTokens: parsed.usage.total_tokens ?? 0
                 };
+                this.debug?.("LLM stream usage", { ...usage });
+              } else if (parsed.error) {
+                midStreamError = String(parsed.error);
               }
-              continue;
-            }
-            const delta = choice.delta || {};
-            const finishReason = choice.finish_reason;
-            if (finishReason)
-              lastFinishReason = finishReason;
-            if (delta.reasoning_content) {
-              onEmit();
-              yield { type: "reasoning", content: delta.reasoning_content };
-            }
-            if (delta.tool_calls) {
-              sawToolCallStart = true;
-              for (const tc of delta.tool_calls) {
-                const idx = tc.index ?? 0;
-                if (!toolCallAccs.has(idx)) {
-                  toolCallAccs.set(idx, { id: "", name: "", arguments: "" });
-                }
-                const acc = toolCallAccs.get(idx);
-                if (tc.id)
-                  acc.id = tc.id;
-                if (tc.function?.name)
-                  acc.name = tc.function.name;
-                if (tc.function?.arguments) {
-                  acc.arguments += tc.function.arguments;
+            } else {
+              if (parsedChunks <= 3 || parsedChunks % 50 === 0) {
+                const d = choice.delta ?? {};
+                this.debug?.("LLM stream chunk", {
+                  n: parsedChunks,
+                  finishReason: choice.finish_reason ?? null,
+                  deltaKeys: Object.keys(d)
+                });
+              }
+              const delta = choice.delta || {};
+              const finishReason = choice.finish_reason;
+              if (finishReason)
+                lastFinishReason = finishReason;
+              const reasoningDelta = delta.reasoning_content ?? delta.reasoning;
+              if (reasoningDelta) {
+                onEmit();
+                yield { type: "reasoning", content: reasoningDelta };
+              }
+              if (delta.tool_calls) {
+                sawToolCallStart = true;
+                for (const tc of delta.tool_calls) {
+                  const idx = tc.index ?? 0;
+                  if (!toolCallAccs.has(idx)) {
+                    toolCallAccs.set(idx, { id: "", name: "", arguments: "" });
+                  }
+                  const acc = toolCallAccs.get(idx);
+                  if (tc.id)
+                    acc.id = tc.id;
+                  if (tc.function?.name)
+                    acc.name = tc.function.name;
+                  if (tc.function?.arguments) {
+                    acc.arguments += tc.function.arguments;
+                  }
                 }
               }
-            }
-            if (delta.content) {
-              onEmit();
-              sawText = true;
-              yield { type: "text", content: delta.content };
-            }
-            if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
-              for (const [, acc] of toolCallAccs) {
-                if (acc.name) {
-                  onEmit();
-                  yield {
-                    type: "tool_call",
-                    toolCall: {
-                      id: acc.id,
-                      name: acc.name,
-                      arguments: acc.arguments || "{}"
-                    }
-                  };
+              if (delta.content) {
+                onEmit();
+                sawText = true;
+                yield { type: "text", content: delta.content };
+              }
+              if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
+                for (const [, acc] of toolCallAccs) {
+                  if (acc.name) {
+                    onEmit();
+                    yield {
+                      type: "tool_call",
+                      toolCall: {
+                        id: acc.id,
+                        name: acc.name,
+                        arguments: acc.arguments || "{}"
+                      }
+                    };
+                  }
                 }
+                toolCallAccs.clear();
               }
-              toolCallAccs.clear();
             }
           } catch {}
+          if (midStreamError) {
+            throw new Error(t("error.llm_provider_stream_error", { error: midStreamError.slice(0, 300) }));
+          }
         }
       }
       if (usage) {
@@ -5760,6 +5868,15 @@ class OpenAICompatProvider {
     } finally {
       cleanup();
       reader.releaseLock();
+      this.debug?.("LLM stream finished", {
+        sawDone,
+        lastFinishReason: lastFinishReason ?? null,
+        sawText,
+        sawToolCallStart,
+        parsedChunks,
+        nonDataLines,
+        nonDataSamples: nonDataLines > 0 ? nonDataSamples : undefined
+      });
     }
     return sawDone;
   }
@@ -5806,7 +5923,8 @@ class OpenAICompatProvider {
       tools,
       stream: false,
       maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
-      reasoningEffort: options?.reasoningEffort
+      reasoningEffort: options?.reasoningEffort,
+      reasoningStrategy: options?.reasoningStrategy
     });
     const { headers, abortSignal, cleanup, isTimeout } = this.buildRequestSetup(signal);
     try {
@@ -5825,14 +5943,18 @@ class OpenAICompatProvider {
         }));
       }
       const data = await response.json();
+      if (data.error && !data.choices) {
+        throw new Error(t("error.llm_provider_stream_error", { error: String(data.error).slice(0, 300) }));
+      }
       const choice = data.choices?.[0];
       if (!choice) {
         return [];
       }
       const msg = choice.message || {};
       const chunks = [];
-      if (msg.reasoning_content) {
-        chunks.push({ type: "reasoning", content: msg.reasoning_content });
+      const reasoning = msg.reasoning_content ?? msg.reasoning;
+      if (reasoning) {
+        chunks.push({ type: "reasoning", content: reasoning });
       }
       if (msg.content) {
         chunks.push({ type: "text", content: msg.content });
@@ -5976,7 +6098,8 @@ function openaiCompat(opts) {
     contextWindow: opts.contextWindow,
     retry,
     rateLimits,
-    maxCompletionTokens: opts.maxCompletionTokens
+    maxCompletionTokens: opts.maxCompletionTokens,
+    logger: opts.logger
   });
 }
 var OPENAI_COMPAT, OPENROUTER, OPENAI, ANTHROPIC, OPENCODE_ZEN, OPENCODE_GO, BUILTIN_PROVIDERS, HOSTED_BASE_URLS;
@@ -5990,7 +6113,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: false,
-      reasoningEffort: false,
+      reasoningStrategy: "prompt-tag",
       listModels: true,
       requiresKey: false,
       auth: "bearer"
@@ -6005,7 +6128,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: true,
-      reasoningEffort: false,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: true,
       auth: "bearer"
@@ -6020,7 +6143,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: true,
-      reasoningEffort: true,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: true,
       auth: "bearer"
@@ -6035,7 +6158,7 @@ var init_presets = __esm(() => {
       streaming: false,
       tools: false,
       vision: true,
-      reasoningEffort: false,
+      reasoningStrategy: "none",
       listModels: false,
       requiresKey: true,
       auth: "header"
@@ -6050,7 +6173,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: false,
-      reasoningEffort: false,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: false,
       auth: "bearer"
@@ -6065,7 +6188,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: false,
-      reasoningEffort: false,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: false,
       auth: "bearer"
@@ -6230,7 +6353,8 @@ class ProviderManager {
       contextWindow: entry.contextWindow ?? this.opts.contextWindow,
       retry: entry.retry ?? this.opts.retry,
       rateLimits: entry.rateLimits ?? this.opts.rateLimits,
-      maxCompletionTokens: entry.maxCompletionTokens
+      maxCompletionTokens: entry.maxCompletionTokens,
+      logger: this.opts.logger
     }, this.registry);
     this.cache.set(key, provider);
     return provider;
@@ -6562,6 +6686,8 @@ class ToolExecutor {
         const timeoutPromise = new Promise((_, reject) => {
           setTimeout(() => {
             killByCallId(call.id);
+            this.ctx.cleanup?.();
+            this.ctx.cleanup = undefined;
             reject(new Error(t("tool.timeout", {
               name: call.name,
               seconds: Math.round(timeoutMs / 1000)
@@ -6576,6 +6702,8 @@ class ToolExecutor {
           const abortPromise = new Promise((_, reject) => {
             const onAbort = () => {
               killByCallId(call.id);
+              this.ctx.cleanup?.();
+              this.ctx.cleanup = undefined;
               reject(new Error(t("tool.aborted", { name: call.name })));
             };
             if (signal.aborted) {
@@ -9544,6 +9672,18 @@ class SessionLogger {
       skills: data.skills
     });
   }
+  logReasoningControl(data) {
+    this.session?.appendLog({
+      ts: new Date().toISOString(),
+      type: "reasoning_control",
+      content: `reasoning level: ${data.level} (source: ${data.source ?? "policy"})`,
+      iteration: data.iteration,
+      level: data.level,
+      strategy: data.strategy,
+      probePassed: data.probePassed,
+      source: data.source
+    });
+  }
 }
 var init_session_logger = __esm(() => {
   init_audit_log();
@@ -12651,6 +12791,42 @@ var init_pricing = __esm(() => {
   init_prices();
 });
 
+// src/modules/reasoning/policy.ts
+function createPolicyState() {
+  return { iterationsSinceRaise: 0, boostRemaining: 0 };
+}
+function evaluateReasoningPolicy(input, state) {
+  if (input.hallucinationRetry || input.auditRejection || input.recoverableLlmError) {
+    state.iterationsSinceRaise = 0;
+    return { level: "high", reason: input.hallucinationRetry ? "policy:hallucination-retry" : input.auditRejection ? "policy:audit-rejection" : "policy:recoverable-llm-error" };
+  }
+  if (input.planCreated) {
+    state.boostRemaining = 3;
+    state.iterationsSinceRaise = 0;
+    return { level: "high", reason: "policy:plan-created" };
+  }
+  if (state.boostRemaining > 0) {
+    state.boostRemaining--;
+    state.iterationsSinceRaise = 0;
+    return { level: "high", reason: "policy:plan-boost" };
+  }
+  if (input.consecutiveSuccesses >= 2) {
+    state.iterationsSinceRaise++;
+    return { level: "low", reason: "policy:routine-write" };
+  }
+  if (input.isRepetitive) {
+    state.iterationsSinceRaise++;
+    return { level: "low", reason: "policy:repetitive-tools" };
+  }
+  if (state.iterationsSinceRaise >= DECAY_THRESHOLD) {
+    state.iterationsSinceRaise = 0;
+    return { level: input.baseline, reason: "policy:decay" };
+  }
+  state.iterationsSinceRaise++;
+  return { level: input.baseline, reason: "policy:default" };
+}
+var DECAY_THRESHOLD = 5;
+
 // src/core/agent.ts
 function isToolCallJson(text) {
   const trimmed = text.trim();
@@ -12678,13 +12854,28 @@ class Agent {
   abortController = null;
   lastCompactionShown = 0;
   costTracker;
+  policyState;
+  reasoningState;
+  _currentIteration = 0;
   constructor(deps) {
     this.deps = deps;
     this.costTracker = new CostTracker(deps.config.model, deps.config.pricing);
+    this.policyState = createPolicyState();
+    const initialLevel = (deps.config.reasoning?.mode !== "auto" ? deps.config.reasoning?.mode : undefined) ?? "medium";
+    this.reasoningState = { level: initialLevel, overrideIteration: -100 };
   }
   get contextManager() {
     return this.deps.contextManager;
   }
+  get reasoningLevel() {
+    return this.reasoningState.level;
+  }
+  setReasoningLevel(level) {
+    this.reasoningState.level = level;
+  }
+  get currentIteration() {
+    return this._currentIteration;
+  }
   callerProvenance() {
     return {
       provider: this.deps.config.provider?.type || "unknown",
@@ -12912,13 +13103,22 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
     let repeatedToolCount = 0;
     const MAX_REPEATED_TOOL_CALLS = 2;
     let llmErrorRetries = 0;
+    let iterHallucinationRetry = false;
+    let iterAuditRejection = false;
+    let iterRecoverableLlmError = false;
+    let iterPlanCreated = false;
     let allToolsForBudget = toolExecutor.getToolDefinitions(this.deps.toolTags);
     let boundedToolNames = new Set(allToolsForBudget.filter((t2) => t2.boundedOutput).map((t2) => t2.name));
     let toolTokenEstimate = allToolsForBudget.reduce((sum, t2) => sum + Math.ceil((t2.description.length + JSON.stringify(t2.parameters).length) / 4), 0);
     contextManager.setToolTokens(toolTokenEstimate);
     while (iteration < config.maxToolIterations && !this.shutdownRequested) {
       iteration++;
+      this._currentIteration = iteration;
       contextManager.noteIteration();
+      iterHallucinationRetry = false;
+      iterAuditRejection = false;
+      iterRecoverableLlmError = false;
+      iterPlanCreated = false;
       allToolsForBudget = toolExecutor.getToolDefinitions(this.deps.toolTags);
       boundedToolNames = new Set(allToolsForBudget.filter((t2) => t2.boundedOutput).map((t2) => t2.name));
       toolTokenEstimate = allToolsForBudget.reduce((sum, t2) => sum + Math.ceil((t2.description.length + JSON.stringify(t2.parameters).length) / 4), 0);
@@ -12989,8 +13189,35 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
       const promptBefore = apiPromptTokens;
       const completionBefore = apiCompletionTokens;
       logger.logLLMRequest(config.model, history.length, input, "agent");
+      const reasoningConfig = config.reasoning;
+      let effectiveReasoningLevel;
+      let reasoningStrategy = this.deps.reasoningStrategy;
+      if (reasoningConfig && reasoningConfig.mode === "auto" && this.deps.reasoningProbePassed) {
+        const policyResult = evaluateReasoningPolicy({
+          hallucinationRetry: iterHallucinationRetry,
+          auditRejection: iterAuditRejection,
+          recoverableLlmError: iterRecoverableLlmError,
+          planCreated: iterPlanCreated,
+          consecutiveSuccesses: 0,
+          isRepetitive: false,
+          baseline: "medium"
+        }, this.policyState);
+        effectiveReasoningLevel = policyResult.level;
+      } else if (reasoningConfig && reasoningConfig.mode !== "auto") {
+        effectiveReasoningLevel = reasoningConfig.mode;
+      }
+      if (effectiveReasoningLevel) {
+        slog.logReasoningControl({
+          iteration,
+          level: effectiveReasoningLevel,
+          strategy: reasoningStrategy,
+          probePassed: this.deps.reasoningProbePassed,
+          source: this.reasoningState.overrideIteration === iteration ? "agent_override" : "policy"
+        });
+        contextManager.thinkingLevel = effectiveReasoningLevel;
+      }
       try {
-        for await (const chunk of llmProvider.chat(history, allToolsForBudget, this.abortController?.signal)) {
+        for await (const chunk of llmProvider.chat(history, allToolsForBudget, this.abortController?.signal, effectiveReasoningLevel ? { reasoningEffort: effectiveReasoningLevel, reasoningStrategy } : undefined)) {
           if (this.shutdownRequested)
             break;
           if (chunk.type === "text" && chunk.content) {
@@ -13037,6 +13264,7 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
           break;
         }
         if (err?.recoverableLlm && llmErrorRetries < MAX_LLM_ERROR_RETRIES) {
+          iterRecoverableLlmError = true;
           llmErrorRetries++;
           logger.warn(`Recoverable LLM error, feeding back (${llmErrorRetries}/${MAX_LLM_ERROR_RETRIES}): ${err.message}`);
           slog.logError(err.message);
@@ -13313,6 +13541,7 @@ ${warnLine}
         }
       }
       if (hallucinationResult.status === "retry") {
+        iterHallucinationRetry = true;
         if (this.deps.exitOnComplete && textContent?.trim() && !this.deps.finalAudit) {
           logger.debug("Exit-on-complete: stopping on first response");
           lastText = textContent;
@@ -13391,6 +13620,7 @@ ${warnLine}
         if (this.deps.finalAudit) {
           const audit = await this.deps.finalAudit();
           if (audit && !audit.passed) {
+            iterAuditRejection = true;
             logger.warn(`Final audit incomplete: ${audit.summary}`);
             const steps = audit.pendingSteps.slice(0, 5).join("; ") || "—";
             contextManager.addMessage({
@@ -13478,7 +13708,8 @@ ${warnLine}
     const manager = new ProviderManager(this.deps.config.provider, {
       contextWindow: this.deps.config.contextWindow,
       retry: this.deps.config.retry,
-      rateLimits: this.deps.config.security?.rateLimits
+      rateLimits: this.deps.config.security?.rateLimits,
+      logger: this.deps.logger
     });
     manager.switch(name, model);
     const providerCfg = manager.toConfig();
@@ -13504,7 +13735,8 @@ ${warnLine}
       const manager = new ProviderManager(this.deps.config.provider, {
         contextWindow: this.deps.config.contextWindow,
         retry: this.deps.config.retry,
-        rateLimits: this.deps.config.security?.rateLimits
+        rateLimits: this.deps.config.security?.rateLimits,
+        logger: this.deps.logger
       });
       manager.setModel(this.deps.config.model);
       manager.switch(name);
@@ -13746,6 +13978,7 @@ class ContextManager {
   tokenCounter;
   pendingImageParts = [];
   toolTokens = 0;
+  thinkingLevel = null;
   onCompact = null;
   planSummaryProvider = null;
   constructor(contextWindow, contextBudget, tokenCounter) {
@@ -13939,6 +14172,8 @@ class ContextManager {
     const errorsLine = this.facts.errorsLine();
     if (errorsLine)
       parts.push(errorsLine);
+    if (this.thinkingLevel)
+      parts.push(`[Thinking: ${this.thinkingLevel}]`);
     const triedAndFailed = extractTriedAndFailed(oldTurns);
     if (triedAndFailed.length > 0) {
       const lines = triedAndFailed.map((t2) => `- ${t2.tool}(${t2.args}): ${t2.error} (failed ${t2.count}x)`);
@@ -14759,6 +14994,7 @@ var init_subagent = __esm(() => {
     icon: "\uD83E\uDD16",
     description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
     tags: ["code"],
+    timeoutMs: 180000,
     parameters: {
       type: "object",
       properties: {
@@ -14851,6 +15087,7 @@ var init_subagent = __esm(() => {
         const hallucinationDetector = new HallucinationDetector(ctx.baseDir, ctx.llmProvider);
         const parentScope = ctx.scope;
         ctx.toolExecutor.setScope(scope || { allowed_files: [], read_only_files: [] });
+        ctx.cleanup = () => ctx.toolExecutor?.setScope(parentScope);
         const systemPrompt = {
           content: buildSubagentSystemPrompt(context, ctx.config.subagent?.stableSystemPrompt !== false),
           priority: "critical",
@@ -14912,6 +15149,7 @@ Iterations: ${result.iterationCount}`
           };
         } finally {
           ctx.toolExecutor.setScope(parentScope);
+          ctx.cleanup = undefined;
         }
       } catch (e) {
         return { success: false, output: `Sub-agent error: ${e.message}` };
@@ -15091,7 +15329,7 @@ var init_chunk_query = __esm(() => {
         },
         reasoning_effort: {
           type: "string",
-          enum: ["none", "low", "medium", "high"],
+          enum: ["none", "low", "medium", "high", "max"],
           description: 'Reasoning effort for chunk/synthesis calls (default "none"). "none" prevents long thinking chains from eating the token budget on reasoning models.'
         },
         synthesize: {
@@ -15131,7 +15369,7 @@ var init_chunk_query = __esm(() => {
         synthesize: typeof args.synthesize === "boolean" ? args.synthesize : undefined,
         maxChunkTokens: typeof args.max_chunk_tokens === "number" ? args.max_chunk_tokens : undefined,
         maxSynthesisTokens: typeof args.max_synthesis_tokens === "number" ? args.max_synthesis_tokens : undefined,
-        reasoningEffort: ["none", "low", "medium", "high"].includes(args.reasoning_effort) ? args.reasoning_effort : undefined,
+        reasoningEffort: ["none", "low", "medium", "high", "max"].includes(args.reasoning_effort) ? args.reasoning_effort : undefined,
         logger: ctx.logger
       });
       ctx.logger.debug(`chunk_query: ${res.chunks} chunk(s), ${res.totalChars} chars, max parallel ${res.maxParallelObserved}`);
@@ -23341,6 +23579,126 @@ function syncGlobalManifest(override, bundledPathOverride) {
 var certKey = (e) => `${e.model}::${e.providerUrl}`;
 var init_manifest = () => {};
 
+// src/modules/reasoning/probe.ts
+var exports_probe = {};
+__export(exports_probe, {
+  setCachedProbeResult: () => setCachedProbeResult,
+  resetProbeCache: () => resetProbeCache,
+  probeReasoningSupport: () => probeReasoningSupport,
+  getCachedProbeResult: () => getCachedProbeResult,
+  cacheKey: () => cacheKey
+});
+async function probeReasoningSupport(provider, strategy, signal) {
+  if (strategy === "none")
+    return false;
+  try {
+    let hasReasoning = false;
+    for await (const chunk of provider.chat(PROBE_MESSAGES, undefined, signal, {
+      maxTokens: 32,
+      reasoningEffort: "none",
+      reasoningStrategy: strategy
+    })) {
+      if (chunk.type === "reasoning")
+        hasReasoning = true;
+    }
+    return !hasReasoning;
+  } catch {
+    return false;
+  }
+}
+function cacheKey(baseUrl, model) {
+  return `${baseUrl}|${model}`;
+}
+function getCachedProbeResult(key) {
+  return probeCache.get(key);
+}
+function setCachedProbeResult(key, result) {
+  probeCache.set(key, result);
+}
+function resetProbeCache() {
+  probeCache.clear();
+}
+var PROBE_MESSAGES, probeCache;
+var init_probe = __esm(() => {
+  PROBE_MESSAGES = [
+    { role: "user", content: "Reply with exactly: ok" }
+  ];
+  probeCache = new Map;
+});
+
+// src/tools/set-thinking.ts
+var exports_set_thinking = {};
+__export(exports_set_thinking, {
+  createSetThinkingTool: () => createSetThinkingTool
+});
+function createSetThinkingTool(state, config, getCurrentIteration) {
+  return {
+    name: "set_thinking",
+    description: "Set reasoning effort level for the next LLM call. Normally managed automatically by the harness. Use only to force deeper thinking for genuinely hard subproblems or shallower for mechanical batches.",
+    icon: "\uD83E\uDDE0",
+    tags: [],
+    alwaysOn: true,
+    parameters: {
+      type: "object",
+      properties: {
+        level: {
+          type: "string",
+          enum: ["none", "low", "high", "max"],
+          description: "Reasoning effort level to set"
+        },
+        reason: {
+          type: "string",
+          description: "Why changing the level"
+        }
+      },
+      required: ["level"]
+    },
+    handler: async (_ctx, args) => {
+      const requested = args.level;
+      const reason = args.reason || "agent override";
+      if (!VALID_LEVELS.includes(requested) && requested !== "auto") {
+        return {
+          success: false,
+          output: t("tool.thinking_invalid_level", { level: requested })
+        };
+      }
+      const currentIter = getCurrentIteration();
+      const elapsed = currentIter - state.overrideIteration;
+      if (elapsed > 0 && elapsed < config.overrideCooldown) {
+        return {
+          success: true,
+          output: t("tool.thinking_cooldown", {
+            remaining: config.overrideCooldown - elapsed,
+            current: state.level
+          })
+        };
+      }
+      let level = requested;
+      const levelOrder = ["none", "low", "medium", "high", "max"];
+      const minIdx = levelOrder.indexOf(config.min);
+      const maxIdx = levelOrder.indexOf(config.max);
+      const reqIdx = levelOrder.indexOf(level);
+      let clamped = false;
+      if (reqIdx >= 0 && reqIdx < minIdx) {
+        level = config.min;
+        clamped = true;
+      } else if (reqIdx > maxIdx) {
+        level = config.max;
+        clamped = true;
+      }
+      state.level = level;
+      state.overrideIteration = currentIter;
+      const msg = clamped ? t("tool.thinking_set_clamped", { level, reason }) : t("tool.thinking_set", { level, reason });
+      return { success: true, output: msg };
+    }
+  };
+}
+var VALID_LEVELS;
+var init_set_thinking = __esm(() => {
+  init_i18n();
+  VALID_LEVELS = ["default", "none", "low", "medium", "high", "max"];
+});
+
 // src/core/bootstrap.ts
 var exports_bootstrap = {};
 __export(exports_bootstrap, {
@@ -23401,11 +23759,17 @@ function buildSystemInfo(config, baseDir, profileCompressed) {
   return lines.join(`
 `);
 }
-async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
+async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete, reasoningLevel) {
   const dir = configDir || process.env.MMA_CONFIG_DIR || join41(homedir14(), ".mma");
   const projectConfigPath = projectDir ? join41(projectDir, ".mmrc") : join41(process.cwd(), ".mmrc");
   const { config, legacyDetected } = loadConfig({ configDir: dir, projectConfigPath });
   setLocale(config.locale);
+  if (reasoningLevel && reasoningLevel !== "auto") {
+    if (!config.reasoning)
+      config.reasoning = { mode: reasoningLevel, min: "low", max: "high", overrideCooldown: 3 };
+    else
+      config.reasoning.mode = reasoningLevel;
+  }
   try {
     const { globalAuditNotifier: globalAuditNotifier2 } = await Promise.resolve().then(() => (init_audit_notifier(), exports_audit_notifier));
     if (config.security?.auditNotifier) {
@@ -23448,7 +23812,8 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
   const providerManager = new ProviderManager(config.provider, {
     contextWindow: config.contextWindow,
     retry: config.retry,
-    rateLimits: config.security?.rateLimits
+    rateLimits: config.security?.rateLimits,
+    logger
   });
   providerManager.setModel(config.model);
   let llmProvider = providerManager.active;
@@ -23457,6 +23822,29 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
       logger.warn(`provider failover: ${from} -> ${to} (${error.message.slice(0, 120)})`);
     });
   }
+  const providerSpec = BUILTIN_PROVIDERS.find((p) => p.type === config.provider.type);
+  const reasoningStrategy = providerSpec?.capabilities.reasoningStrategy ?? "none";
+  let reasoningProbePassed = false;
+  if (config.reasoning && config.reasoning.mode !== "none" && reasoningStrategy !== "none") {
+    try {
+      const { probeReasoningSupport: probeReasoningSupport2, getCachedProbeResult: getCachedProbeResult2, setCachedProbeResult: setCachedProbeResult2 } = await Promise.resolve().then(() => (init_probe(), exports_probe));
+      const cacheK = `${config.provider.baseUrl ?? ""}|${config.model}`;
+      const cached = getCachedProbeResult2(cacheK);
+      if (cached !== undefined) {
+        reasoningProbePassed = cached;
+      } else {
+        reasoningProbePassed = await probeReasoningSupport2(llmProvider, reasoningStrategy);
+        setCachedProbeResult2(cacheK, reasoningProbePassed);
+      }
+      if (reasoningProbePassed) {
+        logger.info(`Reasoning probe: strategy=${reasoningStrategy} → mechanism respected`);
+      } else {
+        logger.info(`Reasoning probe: strategy=${reasoningStrategy} → mechanism IGNORED`);
+      }
+    } catch {
+      reasoningProbePassed = false;
+    }
+  }
   const baseDir = projectDir ? resolve23(projectDir) : process.cwd();
   const envReport = collectEnvironment({
     configDir: dir,
@@ -23723,9 +24111,16 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     sessionManager,
     memoryStore,
     moduleRegistry,
-    exitOnComplete
+    exitOnComplete,
+    reasoningProbePassed,
+    reasoningStrategy
   };
   const agent = new Agent(agentDeps);
+  if (config.reasoning) {
+    const { createSetThinkingTool: createSetThinkingTool2 } = await Promise.resolve().then(() => (init_set_thinking(), exports_set_thinking));
+    const setThinkingTool = createSetThinkingTool2(agent.reasoningState, config.reasoning, () => agent.currentIteration);
+    toolRegistry.register(setThinkingTool);
+  }
   return {
     agent,
     config,
@@ -23746,6 +24141,7 @@ var init_bootstrap = __esm(() => {
   init_config2();
   init_app_logger();
   init_providers();
+  init_presets();
   init_tools();
   init_hidden_tools_block();
   init_executor();
@@ -31528,7 +31924,8 @@ var init_scenarios = __esm(() => {
     }
   };
   PROVIDER_BASE = {
-    provider: { maxCompletionTokens: 16384 }
+    provider: { maxCompletionTokens: 16384 },
+    reasoning: { mode: "none", min: "low", max: "high", overrideCooldown: 3 }
   };
   SCENARIO_DEFS = [
     {
@@ -32856,10 +33253,19 @@ function registerMmaCommands(ctx) {
     name: "reasoning",
     description: t("repl.reasoning"),
     usage: t("repl.reasoning_usage"),
-    action: () => {
-      ctx.config.showReasoning = !ctx.config.showReasoning;
-      const status = ctx.config.showReasoning ? pc2.green(t("repl.show")) : pc2.dim(t("repl.hide"));
-      console.log(t("repl.reasoning_status", { status }));
+    action: (args) => {
+      const level = args[0]?.trim().toLowerCase();
+      const VALID_LEVELS2 = ["auto", "none", "low", "medium", "high", "max"];
+      if (!level) {
+        ctx.config.showReasoning = !ctx.config.showReasoning;
+        const status = ctx.config.showReasoning ? pc2.green(t("repl.show")) : pc2.dim(t("repl.hide"));
+        console.log(t("repl.reasoning_status", { status }));
+      } else if (VALID_LEVELS2.includes(level)) {
+        ctx.agent.setReasoningLevel(level);
+        console.log(pc2.green(t("repl.reasoning_level_set", { level })));
+      } else {
+        console.log(pc2.yellow(t("repl.reasoning_invalid_level", { level, valid: VALID_LEVELS2.join(", ") })));
+      }
     }
   });
   ctx.registerCommand({
@@ -34101,7 +34507,7 @@ init_presets();
 init_version();
 var version = readMmaVersion();
 function createProgram() {
-  const program2 = new Command().name("mma").description(t("cli.description")).version(version).option("--no-agents-md", t("cli.no_agents_md")).option("-d, --dir <path>", t("cli.dir")).option("-e, --exit-on-complete", t("cli.exit_on_complete")).option("-j, --json", t("cli.json"));
+  const program2 = new Command().name("mma").description(t("cli.description")).version(version).option("--no-agents-md", t("cli.no_agents_md")).option("-d, --dir <path>", t("cli.dir")).option("-e, --exit-on-complete", t("cli.exit_on_complete")).option("-j, --json", t("cli.json")).option("--reasoning <level>", t("cli.reasoning_level"), "auto");
   program2.command("init").description(t("cli.init")).action(async () => {
     const answers = await runSetup();
     const configPath = join47(homedir16(), ".mma", "config.json");
@@ -36832,13 +37238,14 @@ async function main() {
   const projectDir = opts.dir;
   const exitOnComplete = opts.exitOnComplete === true;
   const jsonMode = opts.json === true;
+  const reasoningLevel = opts.reasoning;
   const isSubcommand = program2.args.length > 0 && cmdNames.has(program2.args[0]);
   if (isSubcommand) {
     return;
   }
   if (program2.args.length > 0) {
     const prompt = program2.args.join(" ");
-    const { agent, config, baseDir, legacyDetected } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
+    const { agent, config, baseDir, legacyDetected } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete, reasoningLevel);
     if (legacyDetected) {
       console.error(pc2.yellow(`  ${t("config.legacy_hint")}`));
     }