micro-models-agent 0.54.0 → 0.55.0

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
     }
   };
 });
@@ -2642,7 +2648,7 @@ Fix the error and re-edit the file (a clean write clears the failure), or mark t
     "cli.model_fetch_failed": "Failed to fetch models: {error}",
     "cli.available_models": "Available models:",
     "cli.cert_label": "supported — certified on this provider",
-    "cli.cert_stale_label": "certified on an older MMA version — re-run certify --force",
+    "cli.cert_stale_label": "certified on an older MMA version — recommended",
     "cli.no_models_found": "No models found from provider",
     "cli.fetching_models": "Fetching model list...",
     "cli.manage_context": "Manage context window",
@@ -2708,6 +2714,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 +2773,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 +3076,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.',
@@ -3373,7 +3391,7 @@ var init_ru = __esm(() => {
     "cli.model_fetch_failed": "Не удалось получить модели: {error}",
     "cli.available_models": "Доступные модели:",
     "cli.cert_label": "поддерживается — сертифицирована на этом провайдере",
-    "cli.cert_stale_label": "сертифицирована на старой версии MMA — перезапустите certify --force",
+    "cli.cert_stale_label": "сертифицирована на старой версии MMA — рекомендуется",
     "cli.no_models_found": "Модели не найдены у провайдера",
     "cli.fetching_models": "Загрузка списка моделей...",
     "cli.manage_context": "Управление контекстным окном",
@@ -3435,6 +3453,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 +3512,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 +3822,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 +4323,8 @@ var init_domains = __esm(() => {
       "autoPlan",
       "showReasoning",
       "logLevel",
-      "locale"
+      "locale",
+      "reasoning"
     ],
     provider: ["provider", "orchestrator", "retry", "pricing"],
     moe: ["moe", "experts"],
@@ -5507,8 +5538,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) => ({
@@ -5550,7 +5587,11 @@ class OpenAICompatProvider {
       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 +5602,29 @@ class OpenAICompatProvider {
       yield chunk;
     }
     if (!hasToolCall && !hasText) {
-      const fallback = await this.doNonStreaming(messages, tools, signal, options);
+      const fallback = await this.doNonStreaming(effectiveMessages, tools, signal, options);
       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 +5659,8 @@ class OpenAICompatProvider {
       tools,
       stream: true,
       maxTokens,
-      reasoningEffort: options?.reasoningEffort
+      reasoningEffort: options?.reasoningEffort,
+      reasoningStrategy: options?.reasoningStrategy
     });
     const { headers, abortSignal, cleanup, isTimeout, flagTimeout, controller } = this.buildRequestSetup(signal);
     let response;
@@ -5806,7 +5865,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 {
@@ -5990,7 +6050,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: false,
-      reasoningEffort: false,
+      reasoningStrategy: "prompt-tag",
       listModels: true,
       requiresKey: false,
       auth: "bearer"
@@ -6005,7 +6065,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: true,
-      reasoningEffort: false,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: true,
       auth: "bearer"
@@ -6020,7 +6080,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: true,
-      reasoningEffort: true,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: true,
       auth: "bearer"
@@ -6035,7 +6095,7 @@ var init_presets = __esm(() => {
       streaming: false,
       tools: false,
       vision: true,
-      reasoningEffort: false,
+      reasoningStrategy: "none",
       listModels: false,
       requiresKey: true,
       auth: "header"
@@ -6050,7 +6110,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: false,
-      reasoningEffort: false,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: false,
       auth: "bearer"
@@ -6065,7 +6125,7 @@ var init_presets = __esm(() => {
       streaming: true,
       tools: true,
       vision: false,
-      reasoningEffort: false,
+      reasoningStrategy: "openai-effort",
       listModels: true,
       requiresKey: false,
       auth: "bearer"
@@ -6562,6 +6622,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 +6638,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 +9608,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 +12727,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 +12790,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 +13039,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 +13125,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 +13200,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 +13477,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 +13556,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({
@@ -13746,6 +13912,7 @@ class ContextManager {
   tokenCounter;
   pendingImageParts = [];
   toolTokens = 0;
+  thinkingLevel = null;
   onCompact = null;
   planSummaryProvider = null;
   constructor(contextWindow, contextBudget, tokenCounter) {
@@ -13939,6 +14106,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 +14928,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 +15021,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 +15083,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 +15263,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 +15303,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 +23513,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 +23693,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) {
@@ -23457,6 +23755,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 +24044,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 +24074,7 @@ var init_bootstrap = __esm(() => {
   init_config2();
   init_app_logger();
   init_providers();
+  init_presets();
   init_tools();
   init_hidden_tools_block();
   init_executor();
@@ -31528,7 +31857,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 +33186,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 +34440,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 +37171,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")}`));
     }

package/package.json

@@ -1,50 +1,50 @@
-{
-  "name": "micro-models-agent",
-  "version": "0.54.0",
-  "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
-  "type": "module",
-  "bin": {
-    "mma": "bin/mma.mjs"
-  },
-  "files": [
-    "dist/",
-    "bin/"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "mma": "bun run src/cli/main.ts",
-    "build": "bun run build:tsc && bun run build:copy-assets",
-    "build:tsc": "tsc -p tsconfig.build.json",
-    "build:copy-assets": "bun run scripts/copy-assets.ts",
-    "build:prod": "bun run 'build:bundle' && bun run 'build:copy-assets'",
-    "build:clean": "cmd /c \"if exist dist rmdir /s /q dist\"",
-    "build:bundle": "bun build ./src/cli/main.ts --outfile ./dist/main.js --target node --format esm --external playwright",
-    "dev": "bun --watch src/cli/main.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "bun test",
-    "test:watch": "bun test --watch",
-    "test:integration": "vitest run --config vitest.integration.config.ts",
-    "format": "prettier --write \"src/**/*.{ts,js,mjs,json}\" \"tests/**/*.{ts,js,json}\" \"scripts/**/*.ts\" \"*.{ts,json}\"",
-    "format:check": "prettier --check \"src/**/*.{ts,js,mjs,json}\" \"tests/**/*.{ts,js,json}\" \"scripts/**/*.ts\" \"*.{ts,json}\""
-  },
-  "dependencies": {
-    "commander": "^12.0.0",
-    "js-tiktoken": "^1.0.0",
-    "jsonrepair": "^3.15.0",
-    "picocolors": "^1.1.1",
-    "playwright": "^1.62.0",
-    "string-width": "^8.2.2",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/bun": "^1.4.0",
-    "@types/node": "^26.3.0",
-    "@vitest/coverage-v8": "^4.1.11",
-    "prettier": "^3.9.6",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^7.0.2",
-    "vitest": "^4.1.11"
-  }
-}
+{
+  "name": "micro-models-agent",
+  "version": "0.55.0",
+  "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
+  "type": "module",
+  "bin": {
+    "mma": "bin/mma.mjs"
+  },
+  "files": [
+    "dist/",
+    "bin/"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "mma": "bun run src/cli/main.ts",
+    "build": "bun run build:tsc && bun run build:copy-assets",
+    "build:tsc": "tsc -p tsconfig.build.json",
+    "build:copy-assets": "bun run scripts/copy-assets.ts",
+    "build:prod": "bun run 'build:bundle' && bun run 'build:copy-assets'",
+    "build:clean": "cmd /c \"if exist dist rmdir /s /q dist\"",
+    "build:bundle": "bun build ./src/cli/main.ts --outfile ./dist/main.js --target node --format esm --external playwright",
+    "dev": "bun --watch src/cli/main.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "format": "prettier --write \"src/**/*.{ts,js,mjs,json}\" \"tests/**/*.{ts,js,json}\" \"scripts/**/*.ts\" \"*.{ts,json}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,js,mjs,json}\" \"tests/**/*.{ts,js,json}\" \"scripts/**/*.ts\" \"*.{ts,json}\""
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "js-tiktoken": "^1.0.0",
+    "jsonrepair": "^3.15.0",
+    "picocolors": "^1.1.1",
+    "playwright": "^1.62.0",
+    "string-width": "^8.2.2",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.0",
+    "@types/node": "^26.3.0",
+    "@vitest/coverage-v8": "^4.1.11",
+    "prettier": "^3.9.6",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.11"
+  }
+}