@phuetz/code-buddy 1.1.0 → 1.2.0

package/dist/agent/codebuddy-agent.js

@@ -14,7 +14,7 @@ import { ToolHandler } from "./tool-handler.js";
 import { BaseAgent } from "./base-agent.js";
 import { createAgentInfrastructureSync } from "./infrastructure/index.js";
 import { getLaneQueue } from "../concurrency/lane-queue.js";
-import { findSkill, findStarterPack } from "../skills/index.js";
+import { findSkill, findStarterPack, resetSkillRegistry } from "../skills/index.js";
 import { skillMdToUnified } from "../skills/adapters/index.js";
 import { getSkillsHub } from "../skills/hub.js";
 import { MessageQueue } from "./message-queue.js";
@@ -24,6 +24,12 @@ import { initializeMemory, getMemoryManager } from "../memory/persistent-memory.
 import { getUserHooksManager } from "../hooks/user-hooks.js";
 import { isFeatureEnabled } from "../config/feature-flags.js";
 import { getActiveRunStore } from "../observability/run-store.js";
+import { resetIdentityManager } from "../identity/identity-manager.js";
+import { resetHotReloadManager } from "../config/hot-reload/index.js";
+import { resetConfigWatcher } from "../config/hot-reload/watcher.js";
+import { resetPersonaManager } from "../personas/persona-manager.js";
+import { resetEnhancedMemory } from "../memory/enhanced-memory.js";
+import { resetPluginMarketplace } from "../plugins/marketplace.js";
 /**
  * Main agent class that orchestrates conversation with CodeBuddy AI and tool execution
  *
@@ -76,9 +82,10 @@ export class CodeBuddyAgent extends BaseAgent {
      * @param useRAGToolSelection - Enable RAG-based tool selection (default: true)
      */
     constructor(apiKey, baseURL, model, maxToolRounds, useRAGToolSelection = true, systemPromptId, // New: external prompt ID (default, minimal, secure, etc.)
-    workingDirectory, systemPromptAppend) {
+    workingDirectory, systemPromptAppend, initialSystemPromptOverride) {
         super();
         this.systemPromptAppend = systemPromptAppend;
+        this.customSystemPromptOverride = initialSystemPromptOverride?.trim() || null;
         this.visionGroundingModel = process.env.CODEBUDDY_VISION_GROUNDING_MODEL || undefined;
         const initialWorkingDirectory = workingDirectory || process.cwd();
         // Determine model to use
@@ -334,6 +341,27 @@ export class CodeBuddyAgent extends BaseAgent {
                 catch (err) {
                     logger.debug('Failed to register AutoRepairMiddleware (non-critical)', { error: err instanceof Error ? err.message : String(err) });
                 }
+                // Verification enforcement (priority 155) — after >= 3 file changes with
+                // no task_verify/run_tests, nudges the model to verify before finishing.
+                // Closes the "loop completes on no-more-tool-calls without a verify gate"
+                // gap surfaced by the Hermes agentic-loop audit (2026-06-16).
+                try {
+                    const { createVerificationEnforcementMiddleware } = await import('./middleware/verification-enforcement.js');
+                    pipeline.use(createVerificationEnforcementMiddleware());
+                    logger.debug('VerificationEnforcementMiddleware registered in pipeline (priority 155)');
+                }
+                catch (err) {
+                    logger.debug('Failed to register VerificationEnforcementMiddleware (non-critical)', { error: err instanceof Error ? err.message : String(err) });
+                }
+                // Visual validation middleware (priority 156) — suggests taking screenshots of generated Office documents
+                try {
+                    const { VisualValidationMiddleware } = await import('./middleware/visual-validation-middleware.js');
+                    pipeline.use(new VisualValidationMiddleware());
+                    logger.debug('VisualValidationMiddleware registered in pipeline (priority 156)');
+                }
+                catch (err) {
+                    logger.debug('Failed to register VisualValidationMiddleware (non-critical)', { error: err instanceof Error ? err.message : String(err) });
+                }
                 // Quality gate middleware (priority 200) — auto-delegates to specialized agents
                 try {
                     const { createQualityGateMiddleware } = await import('./middleware/quality-gate-middleware.js');
@@ -492,18 +520,22 @@ Look at the screenshot and find the element matching the user's intent. Output o
     }
     async initializeAgentSystemPrompt(systemPromptId, modelName, customInstructions) {
         try {
-            let systemPrompt = await this.promptBuilder.buildSystemPrompt(systemPromptId, modelName, customInstructions);
+            const hasInitialOverride = !!this.customSystemPromptOverride;
+            let systemPrompt = this.customSystemPromptOverride
+                ?? await this.promptBuilder.buildSystemPrompt(systemPromptId, modelName, customInstructions);
             // Inject repoProfile.contextPack if available
-            try {
-                const profiler = getRepoProfiler();
-                const profile = await profiler.getProfile();
-                if (profile.contextPack) {
-                    systemPrompt = `${systemPrompt}\n\n[Repo] ${profile.contextPack}`;
-                    logger.debug('RepoProfiler: injected contextPack into system prompt');
+            if (!hasInitialOverride) {
+                try {
+                    const profiler = getRepoProfiler();
+                    const profile = await profiler.getProfile();
+                    if (profile.contextPack) {
+                        systemPrompt = `${systemPrompt}\n\n[Repo] ${profile.contextPack}`;
+                        logger.debug('RepoProfiler: injected contextPack into system prompt');
+                    }
+                }
+                catch {
+                    // Non-fatal — repo profiling is best-effort
                 }
-            }
-            catch {
-                // Non-fatal — repo profiling is best-effort
             }
             systemPrompt = this.applyRuntimeSystemPromptAppend(systemPrompt);
             // Knowledge base is already injected by PromptBuilder.buildSystemPrompt() — skip duplicate injection here.
@@ -1639,7 +1671,9 @@ Look at the screenshot and find the element matching the user's intent. Output o
         // Fire SessionEnd user hook (non-blocking). Shutdown errors should be
         // visible (warn, not debug) — silent debug logs masked prior bugs.
         getUserHooksManager(process.cwd()).executeHooks('SessionEnd', {}).catch((err) => logger.warn(`[user-hooks] SessionEnd error: ${err instanceof Error ? err.message : String(err)}`));
-        if (isFeatureEnabled('USER_MODEL_DIALECTIC_ON_SESSION_END')) {
+        const skipAsyncSessionLearning = process.env.CODEBUDDY_HEADLESS === 'true' ||
+            process.env.CODEBUDDY_HEADLESS === '1';
+        if (!skipAsyncSessionLearning && isFeatureEnabled('USER_MODEL_DIALECTIC_ON_SESSION_END')) {
             const chatHistory = this.historyManager.getChatHistory();
             if (chatHistory && chatHistory.length > 0) {
                 import('../memory/user-model.js')
@@ -1659,7 +1693,7 @@ Look at the screenshot and find the element matching the user's intent. Output o
         // WS3-T1 — session-end flush: handoff + review-gated lesson candidates.
         // Fire-and-forget like the dialectic above; callers that need the flush
         // to complete before process exit await runSessionEndFlush directly.
-        {
+        if (!skipAsyncSessionLearning) {
             const chatHistory = this.historyManager.getChatHistory();
             if (chatHistory && chatHistory.length > 0) {
                 import('./session-end-flush.js')
@@ -1696,6 +1730,27 @@ Look at the screenshot and find the element matching the user's intent. Output o
         this.contextManager.stopPeriodicSnapshot?.();
         this.peerRoutingConfig = null;
         super.dispose();
+        if (skipAsyncSessionLearning) {
+            cleanupHeadlessSingletonWatchers();
+        }
+    }
+}
+function cleanupHeadlessSingletonWatchers() {
+    for (const cleanup of [
+        resetSkillRegistry,
+        resetIdentityManager,
+        resetHotReloadManager,
+        resetConfigWatcher,
+        resetPersonaManager,
+        resetEnhancedMemory,
+        resetPluginMarketplace,
+    ]) {
+        try {
+            cleanup();
+        }
+        catch (error) {
+            logger.debug('Headless watcher cleanup skipped', { error: String(error) });
+        }
     }
 }
 //# sourceMappingURL=codebuddy-agent.js.map

package/dist/agent/execution/agent-executor.js

@@ -7,6 +7,7 @@
  *
  * @module agent/execution
  */
+import { normalizeHallucinatedLocalToolCall } from "../tool-handler.js";
 import { logger } from "../../utils/logger.js";
 import { getErrorMessage } from "../../errors/index.js";
 import { sanitizeToolResult } from "../../utils/sanitize.js";
@@ -32,6 +33,22 @@ function withTimeout(promise, ms, fallback) {
         new Promise(resolve => setTimeout(() => resolve(fallback), ms)),
     ]);
 }
+function isIgnorableControlToolCall(toolCall) {
+    const name = toolCall.function?.name?.trim();
+    if (!name)
+        return true;
+    // Some local models leak thinking/channel markers as tool names. Keep
+    // malformed-but-actionable aliases such as `thought-tool:execute_command`
+    // because ToolHandler normalizes those to real tools.
+    if (normalizeHallucinatedLocalToolCall(name, {}))
+        return false;
+    const lower = name.toLowerCase();
+    return (lower === 'thought' ||
+        lower === 'thought|' ||
+        lower.startsWith('thought|') ||
+        lower.includes('<|channel>') ||
+        lower.includes('<|tool_call>'));
+}
 // Lazy-loaded workspace context to avoid blocking tests.
 // Includes a 3s hard timeout so git commands never stall the agent loop.
 let _getWorkspaceContext = null;
@@ -418,6 +435,21 @@ export class AgentExecutor {
         const maxToolRounds = this.config.maxToolRounds;
         let toolRounds = 0;
         let totalOutputTokens = 0;
+        // In-loop recovery budgets (Hermes parity): bound re-prompts WITHIN a turn
+        // so a length-truncated or post-tool-empty response is recovered instead of
+        // returned half-written. 0 disables. Per-turn counters.
+        const parseRecoveryBudget = (raw, dflt) => {
+            const n = Number.parseInt(raw ?? '', 10);
+            return Number.isFinite(n) && n >= 0 ? n : dflt;
+        };
+        const maxLengthContinuations = parseRecoveryBudget(process.env.CODEBUDDY_MAX_LENGTH_CONTINUATIONS, 3);
+        // Length-continuation ships ON (default 3, real-tested). The post-tool
+        // empty-response re-prompt is harder to trigger deterministically with a
+        // real model, so it ships OFF by default (no untested-by-default behaviour
+        // in the hot loop) — opt in with CODEBUDDY_MAX_EMPTY_RETRIES=N.
+        const maxEmptyRetries = parseRecoveryBudget(process.env.CODEBUDDY_MAX_EMPTY_RETRIES, 0);
+        let lengthContinuations = 0;
+        let emptyRetries = 0;
         // Phase (d).21 ship 4 — start a progress session for this turn.
         // The default sink (boot-wired) logs at 25/50/75/100. Lazy-import to
         // avoid circular load at module init time.
@@ -485,12 +517,14 @@ export class AgentExecutor {
                 // shrink the tool set to ~5 with a minimal alwaysInclude — we
                 // don't want to dangle `remember`/`lessons_*` in front of a model
                 // that can't actually call tools and would inline-hallucinate them.
-                let selectionOpts = {};
+                const activeModelName = this.deps.client.getCurrentModel() ?? '';
+                let selectionOpts = activeModelName ? { modelName: activeModelName } : {};
                 try {
                     const { getModelToolConfig } = await import('../../config/model-tools.js');
-                    const cfg = getModelToolConfig(this.deps.client.getCurrentModel() ?? '');
+                    const cfg = getModelToolConfig(activeModelName);
                     if (cfg.promptProfile === 'lite') {
                         selectionOpts = {
+                            ...selectionOpts,
                             maxTools: 5,
                             alwaysInclude: ['view_file', 'bash', 'search'],
                         };
@@ -499,8 +533,9 @@ export class AgentExecutor {
                 catch { /* model-tools optional, never block */ }
                 const selectionResult = await this.deps.toolSelectionStrategy.selectToolsForQuery(message, selectionOpts);
                 let tools = selectionResult.tools;
+                let forcedChatOnlyToolRunModel = null;
                 if (toolRounds === 0)
-                    this.deps.toolSelectionStrategy.cacheTools(tools);
+                    this.deps.toolSelectionStrategy.cacheTools(tools, activeModelName);
                 // If the active model is flagged `supportsToolCalls: false` in
                 // model-tools.ts (typical of small Ollama / LM Studio models that
                 // can't reliably emit OpenAI-style tool_call frames), drop the
@@ -515,12 +550,17 @@ export class AgentExecutor {
                     // `(client as { defaultModel? }).defaultModel` access always
                     // resolved to undefined because that field doesn't exist on
                     // the dispatcher class — left the guard latent for ages.
-                    const modelName = this.deps.client.getCurrentModel() ?? '';
+                    const modelName = activeModelName;
                     if (modelName) {
                         const cfg = getModelToolConfig(modelName);
                         if (cfg.supportsToolCalls === false && tools.length > 0) {
-                            logger.debug(`[agent-executor] supportsToolCalls=false for ${modelName} — dropping ${tools.length} tools from chat call`);
-                            tools = [];
+                            if (process.env.GROK_FORCE_TOOLS === 'true') {
+                                forcedChatOnlyToolRunModel = modelName;
+                            }
+                            else {
+                                logger.debug(`[agent-executor] supportsToolCalls=false for ${modelName} — dropping ${tools.length} tools from chat call`);
+                                tools = [];
+                            }
                         }
                     }
                 }
@@ -597,7 +637,7 @@ export class AgentExecutor {
                         yield { type: "token_count", tokenCount: inputTokens + result.tokenCount };
                     }
                 }
-                if (!this.deps.streamingHandler.hasYieldedToolCalls()) {
+                if (tools.length > 0 && !this.deps.streamingHandler.hasYieldedToolCalls()) {
                     const extracted = this.deps.streamingHandler.extractToolCalls();
                     if (extracted.toolCalls.length > 0) {
                         yield { type: "tool_calls", toolCalls: extracted.toolCalls };
@@ -605,9 +645,33 @@ export class AgentExecutor {
                 }
                 const accumulatedMessage = this.deps.streamingHandler.getAccumulatedMessage();
                 // Sanitize streamed assistant content: strip model control tokens and invisible chars
-                const rawStreamedContent = accumulatedMessage.content || "Using tools to help you...";
+                let toolCalls = accumulatedMessage.tool_calls;
+                if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+                    const filteredToolCalls = toolCalls.filter((toolCall) => !isIgnorableControlToolCall(toolCall));
+                    if (filteredToolCalls.length !== toolCalls.length) {
+                        logger.debug('[agent-executor] dropped hallucinated control tool calls', {
+                            dropped: toolCalls.length - filteredToolCalls.length,
+                            kept: filteredToolCalls.length,
+                        });
+                    }
+                    toolCalls = filteredToolCalls.length > 0 ? filteredToolCalls : undefined;
+                }
+                const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
+                // Pre-fallback raw content — used by in-loop recovery to tell a real
+                // partial answer (retry-able) from a truly empty turn (give up).
+                const streamedContentRaw = (accumulatedMessage.content || "").trim();
+                const streamFinishReason = accumulatedMessage.finishReason;
+                let rawStreamedContent = accumulatedMessage.content || "";
+                if (forcedChatOnlyToolRunModel && !hasToolCalls && !rawStreamedContent.trim()) {
+                    rawStreamedContent =
+                        `Blocked: ${forcedChatOnlyToolRunModel} is configured as a chat-only local model and ` +
+                            'returned no structured tool call even with GROK_FORCE_TOOLS=true. ' +
+                            'Use a tool-capable model such as qwen3.5-ctx32k or gpt-5.5 for goals that need shell/tools.';
+                    yield { type: "content", content: `${rawStreamedContent}\n` };
+                }
+                if (!rawStreamedContent)
+                    rawStreamedContent = "Using tools to help you...";
                 const content = sanitizeAssistantOutput(rawStreamedContent);
-                const toolCalls = accumulatedMessage.tool_calls;
                 const assistantEntry = {
                     type: "assistant",
                     content: content,
@@ -616,6 +680,9 @@ export class AgentExecutor {
                 };
                 history.push(assistantEntry);
                 messages.push({ role: "assistant", content: content, tool_calls: toolCalls });
+                const currentOutputTokens = this.deps.streamingHandler.getTokenCount() || 0;
+                totalOutputTokens += currentOutputTokens;
+                yield { type: "token_count", tokenCount: inputTokens + totalOutputTokens };
                 if (toolCalls && toolCalls.length > 0) {
                     toolRounds++;
                     // Pre-check cost limit before executing tools (estimate only — no side effects)
@@ -703,7 +770,7 @@ export class AgentExecutor {
                         // Use streaming execution for tools that support it (bash, reason, + adapter-based)
                         let result;
                         const _streamToolStartMs = Date.now();
-                        const STREAMING_TOOLS = ['bash', 'reason'];
+                        const STREAMING_TOOLS = ['bash', 'reason', 'generate_document'];
                         if (STREAMING_TOOLS.includes(toolCall.function.name)) {
                             const gen = this.deps.toolHandler.executeToolStreaming(toolCall);
                             let genResult = await gen.next();
@@ -914,8 +981,6 @@ export class AgentExecutor {
                     if (terminateDetectedStreaming)
                         break;
                     inputTokens = this.deps.tokenCounter.countMessageTokens(messages);
-                    const currentOutputTokens = this.deps.streamingHandler.getTokenCount() || 0;
-                    totalOutputTokens += currentOutputTokens;
                     yield { type: "token_count", tokenCount: inputTokens + totalOutputTokens };
                     // Run after_turn middleware (handles cost recording + limit)
                     if (pipeline) {
@@ -942,6 +1007,51 @@ export class AgentExecutor {
                     catch { /* masking is optional */ }
                 }
                 else {
+                    // ── In-loop recovery (Hermes parity) ─────────────────────────────
+                    // Re-prompt WITHIN the turn before accepting this as the final answer.
+                    // Only reachable in the no-tool-calls branch, so we never split a
+                    // tool_call/tool_result pair (keeps transcript-repair invariants intact).
+                    if (!abortController?.signal.aborted) {
+                        // (1) Length truncation: the model hit the output-token cap mid-prose.
+                        // Ask it to continue from where it stopped, bounded. A continuation
+                        // that produced ZERO new tokens (e.g. a too-small num_ctx) leaves
+                        // `streamedContentRaw` empty — we do NOT retry that (the fix is config,
+                        // not looping); we fall through and stop.
+                        if (streamFinishReason === 'length' &&
+                            streamedContentRaw.length > 0 &&
+                            lengthContinuations < maxLengthContinuations) {
+                            lengthContinuations++;
+                            logger.debug('[agent-executor] length-truncation continuation', {
+                                attempt: lengthContinuations,
+                                max: maxLengthContinuations,
+                            });
+                            messages.push({
+                                role: 'user',
+                                content: 'Your previous message was cut off because it reached the output length limit. ' +
+                                    'Continue it from exactly where it stopped — do not repeat earlier text and do not ' +
+                                    'restart. When the full response is complete, finish normally.',
+                            });
+                            continue;
+                        }
+                        // (2) Post-tool empty response: the model went silent after running
+                        // tools. Nudge it to use the results and continue, bounded.
+                        if (streamedContentRaw.length === 0 &&
+                            streamFinishReason !== 'length' &&
+                            toolRounds > 0 &&
+                            emptyRetries < maxEmptyRetries) {
+                            emptyRetries++;
+                            logger.debug('[agent-executor] empty-response re-prompt', {
+                                attempt: emptyRetries,
+                                max: maxEmptyRetries,
+                            });
+                            messages.push({
+                                role: 'user',
+                                content: 'Your last response was empty. Use the results of the tool calls you just made ' +
+                                    'to continue the task and produce your answer.',
+                            });
+                            continue;
+                        }
+                    }
                     // Fire-and-forget auto-capture on final assistant response (streaming)
                     try {
                         const { getAutoCaptureManager } = await import('../../memory/auto-capture.js');

package/dist/agent/execution/tool-dependency-graph.js

@@ -183,6 +183,13 @@ export const TOOL_METADATA = {
         parallelSafe: false, // Single local camera device + explicit privacy boundary
         priority: 6,
     },
+    camera_analyze: {
+        reads: [],
+        writes: ["file"],
+        hasSideEffects: true,
+        parallelSafe: false, // Single local camera device + network vision call
+        priority: 6,
+    },
     diagram: {
         reads: [],
         writes: ["file"],

package/dist/agent/execution/tool-hooks.d.ts

@@ -11,6 +11,12 @@
  * @module agent/execution/tool-hooks
  */
 import type { CodeBuddyMessage } from '../../codebuddy/client.js';
+export type FleetEventBroadcaster = (type: any, payload: any, agentId?: string) => void;
+/**
+ * Register the fleet event broadcaster. Called by the server at boot
+ * to wire up fleet events without introducing a circular dependency.
+ */
+export declare function registerFleetBroadcaster(broadcaster: FleetEventBroadcaster): void;
 /**
  * Emit a fleet event for tool execution. Best-effort: never throws,
  * silently no-ops when fleet streaming is disabled or the WS server

package/dist/agent/execution/tool-hooks.js

@@ -11,11 +11,19 @@
  * @module agent/execution/tool-hooks
  */
 import { getUserHooksManager } from '../../hooks/user-hooks.js';
-// Phase (d).2 V0.4.1 — eager import so concurrent tool emits don't get
-// serialized through dynamic-import promise chains (same fix as (d).3
-// for workflow events). fleet-bridge stays lean; it lazy-imports its
-// own deps so this doesn't bloat CLI-only startup.
-import { broadcastFleetEvent as _broadcastFleetEvent } from '../../server/websocket/fleet-bridge.js';
+let _fleetBroadcaster = null;
+/**
+ * Register the fleet event broadcaster. Called by the server at boot
+ * to wire up fleet events without introducing a circular dependency.
+ */
+export function registerFleetBroadcaster(broadcaster) {
+    _fleetBroadcaster = broadcaster;
+}
+function _broadcastFleetEvent(type, payload, agentId) {
+    if (_fleetBroadcaster) {
+        _fleetBroadcaster(type, payload, agentId);
+    }
+}
 /**
  * Phase (d).2 V0.4.1 — fleet stream opt-in. When CODEBUDDY_FLEET_STREAM=1
  * (or =true), every tool execution emits a fleet:agent:tool_started /

package/dist/agent/execution/tool-selection-strategy.d.ts

@@ -37,6 +37,12 @@ export interface ToolSelectionConfig {
     enableCaching: boolean;
     /** Cache TTL in milliseconds (default: 5 minutes) */
     cacheTTLMs: number;
+    /**
+     * Active model name. When present, model capability rules from
+     * model-tools.ts are applied to the model-facing schemas before they are
+     * cached or sent to the provider.
+     */
+    modelName?: string;
 }
 /**
  * Result of a tool selection operation
@@ -80,6 +86,7 @@ export declare class ToolSelectionStrategy {
     private config;
     private cachedTools;
     private cachedToolNames;
+    private cacheModelName;
     private lastQuery;
     private lastSelection;
     private cacheTimestamp;
@@ -109,13 +116,13 @@ export declare class ToolSelectionStrategy {
      *
      * @param tools - Tools to cache
      */
-    cacheTools(tools: CodeBuddyTool[]): void;
+    cacheTools(tools: CodeBuddyTool[], modelName?: string): void;
     /**
      * Get cached tools if available and valid
      *
      * @returns Cached tools or null if cache is invalid/empty
      */
-    getCachedTools(): CodeBuddyTool[] | null;
+    getCachedTools(modelName?: string): CodeBuddyTool[] | null;
     /**
      * Set the active skill for tool augmentation.
      *
@@ -140,6 +147,8 @@ export declare class ToolSelectionStrategy {
      * Check if the cache is still valid
      */
     private isCacheValid;
+    private static normalizeModelName;
+    private applyModelFacingSchemaFilter;
     /**
      * Record a tool request for metrics tracking
      *

package/dist/agent/execution/tool-selection-strategy.js

@@ -17,6 +17,7 @@
  */
 import { getAllCodeBuddyTools, getRelevantTools, classifyQuery, getSkillAugmentedTools, } from '../../codebuddy/tools.js';
 import { getToolSelector, recordToolRequest, formatToolSelectionMetrics, } from '../../tools/tool-selector.js';
+import { filterToolsForModel, getModelToolConfig, } from '../../config/model-tools.js';
 import { getPromptCacheManager } from '../../optimization/prompt-cache.js';
 import { logger } from '../../utils/logger.js';
 import { getSkillsHub } from '../../skills/hub.js';
@@ -27,10 +28,10 @@ const DEFAULT_CONFIG = {
     useRAG: true,
     maxTools: 15,
     minScore: 0.5,
-    // `remember` is force-included so the LLM can always auto-persist non-obvious
-    // facts to .codebuddy/CODEBUDDY_MEMORY.md, even on tasks where the RAG selector
-    // wouldn't otherwise surface the memory tools (e.g. a pure code-edit query).
-    // Paired with the auto-memory directive in `prompt-builder.ts`.
+    // `remember` and `memory_propose` are force-included so the LLM can always
+    // either persist explicit durable facts or queue inferred/ambiguous facts for
+    // review, even on tasks where the RAG selector wouldn't otherwise surface the
+    // memory tools. Paired with the auto-memory directive in `prompt-builder.ts`.
     //
     // `lessons_add`, `lessons_propose`, and `lessons_search` are force-included for
     // the same reason (Manus AI-inspired self-improvement loop) — paired with the
@@ -38,7 +39,7 @@ const DEFAULT_CONFIG = {
     // "agent proposes, human approves" path, so the model must always see it (a
     // RAG-gated propose tool would rarely surface). `lessons_list` stays out
     // (admin-style, not needed per-turn). Wakes the dormant feature in lessons-tracker.ts.
-    alwaysInclude: ['view_file', 'bash', 'search', 'str_replace_editor', 'web_search', 'remember', 'lessons_add', 'lessons_propose', 'lessons_search'],
+    alwaysInclude: ['view_file', 'bash', 'search', 'str_replace_editor', 'web_search', 'remember', 'memory_propose', 'lessons_add', 'lessons_propose', 'lessons_search'],
     useAdaptiveThreshold: true,
     enableCaching: true,
     cacheTTLMs: 5 * 60 * 1000, // 5 minutes
@@ -68,6 +69,7 @@ export class ToolSelectionStrategy {
     config;
     cachedTools = null;
     cachedToolNames = [];
+    cacheModelName = null;
     lastQuery = '';
     lastSelection = null;
     cacheTimestamp = 0;
@@ -92,9 +94,10 @@ export class ToolSelectionStrategy {
      */
     async selectToolsForQuery(query, options = {}) {
         const effectiveConfig = { ...this.config, ...options };
+        const modelName = ToolSelectionStrategy.normalizeModelName(effectiveConfig.modelName);
         this.lastQuery = query;
         // Check if we should use cached tools
-        if (effectiveConfig.enableCaching && this.isCacheValid()) {
+        if (effectiveConfig.enableCaching && this.isCacheValid(modelName)) {
             logger.debug('Using cached tools for query', { query: query.slice(0, 50) });
             return {
                 tools: this.cachedTools,
@@ -142,6 +145,15 @@ export class ToolSelectionStrategy {
                 toolCount: tools.length,
             });
         }
+        tools = this.applyModelFacingSchemaFilter(tools, modelName);
+        this.cachedToolNames = tools.map(t => t.function.name);
+        if (selection) {
+            selection = {
+                ...selection,
+                selectedTools: tools,
+            };
+            this.lastSelection = selection;
+        }
         // Cache tools for prompt optimization
         const promptCacheManager = getPromptCacheManager();
         promptCacheManager.cacheTools(tools);
@@ -169,14 +181,16 @@ export class ToolSelectionStrategy {
      *
      * @param tools - Tools to cache
      */
-    cacheTools(tools) {
+    cacheTools(tools, modelName) {
         if (!this.config.enableCaching)
             return;
         this.cachedTools = tools;
         this.cachedToolNames = tools.map(t => t.function.name);
+        this.cacheModelName = ToolSelectionStrategy.normalizeModelName(modelName);
         this.cacheTimestamp = Date.now();
         logger.debug('Tools cached for multi-round consistency', {
             toolCount: tools.length,
+            modelName: this.cacheModelName,
         });
     }
     /**
@@ -184,10 +198,10 @@ export class ToolSelectionStrategy {
      *
      * @returns Cached tools or null if cache is invalid/empty
      */
-    getCachedTools() {
+    getCachedTools(modelName) {
         if (!this.config.enableCaching)
             return null;
-        if (!this.isCacheValid())
+        if (!this.isCacheValid(modelName))
             return null;
         return this.cachedTools;
     }
@@ -243,6 +257,7 @@ export class ToolSelectionStrategy {
     clearCache() {
         this.cachedTools = null;
         this.cachedToolNames = [];
+        this.cacheModelName = null;
         this.cacheTimestamp = 0;
         this.activeSkill = null;
         logger.debug('Tool selection cache cleared');
@@ -250,15 +265,57 @@ export class ToolSelectionStrategy {
     /**
      * Check if the cache is still valid
      */
-    isCacheValid() {
+    isCacheValid(modelName) {
         if (!this.cachedTools || this.cachedTools.length === 0)
             return false;
         if (this.cacheTimestamp === 0)
             return false;
+        if (modelName !== undefined) {
+            const normalizedModelName = ToolSelectionStrategy.normalizeModelName(modelName);
+            if (this.cacheModelName !== normalizedModelName)
+                return false;
+        }
         const now = Date.now();
         const age = now - this.cacheTimestamp;
         return age < this.config.cacheTTLMs;
     }
+    static normalizeModelName(modelName) {
+        const normalized = modelName?.trim();
+        return normalized ? normalized : null;
+    }
+    applyModelFacingSchemaFilter(tools, modelName) {
+        if (!modelName || tools.length === 0) {
+            return tools;
+        }
+        try {
+            const modelConfig = getModelToolConfig(modelName);
+            if (modelConfig.supportsToolCalls === false && process.env.GROK_FORCE_TOOLS !== 'true') {
+                logger.debug('Model-facing tool schemas suppressed for chat-only model', {
+                    modelName,
+                    removed: tools.map(t => t.function.name),
+                });
+                return [];
+            }
+            const allowedNames = new Set(filterToolsForModel(tools.map(tool => tool.function.name), modelConfig));
+            const filtered = tools.filter(tool => allowedNames.has(tool.function.name));
+            if (filtered.length !== tools.length) {
+                logger.debug('Model-facing tool schemas filtered by model capabilities', {
+                    modelName,
+                    removed: tools
+                        .map(tool => tool.function.name)
+                        .filter(name => !allowedNames.has(name)),
+                });
+            }
+            return filtered;
+        }
+        catch (error) {
+            logger.debug('Model-facing tool schema filter skipped', {
+                modelName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return tools;
+        }
+    }
     /**
      * Record a tool request for metrics tracking
      *

package/dist/agent/extended-thinking.d.ts

@@ -48,6 +48,14 @@ export declare class ExtendedThinkingManager {
      * Set whether extended thinking is always enabled
      */
     setAlwaysEnabled(value: boolean): void;
+    /**
+     * Apply a UI/settings thinking level — `off | minimal | low | medium | high | xhigh`.
+     * `off` (or any unknown level) disables thinking; any other level enables it with a
+     * scaled token budget. This is the runtime entry point for hot-swapping the level from
+     * the Cowork ReasoningLevelPicker; the OpenAI-compat / Grok / Ollama providers read
+     * {@link getThinkingConfig} fresh per request, so the change takes effect next turn.
+     */
+    applyThinkingLevel(level: string): void;
     /**
      * Get the thinking configuration to merge into API request parameters.
      * Returns an object with a `thinking` key when enabled, or an empty object when disabled.