@phuetz/code-buddy 1.0.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
@@ -121,6 +128,11 @@ export class CodeBuddyAgent extends BaseAgent {
         // This is safe because the singletons returned by getters are the concrete implementations
         this.tokenCounter = this.infrastructure.tokenCounter;
         this.contextManager = this.infrastructure.contextManager;
+        // WS3-T2 — periodic memory snapshot for very long sessions. Interval from
+        // CODEBUDDY_SNAPSHOT_INTERVAL_MIN (default 45 min, 0 disables); the timer
+        // is unref'd so it never keeps a finished process alive. Optional call:
+        // test doubles and custom context engines may not implement snapshots.
+        this.contextManager.startPeriodicSnapshot?.(() => this.historyManager.getMessagesRef());
         this.checkpointManager = this.infrastructure.checkpoints;
         this.sessionStore = this.infrastructure.sessions;
         this.modeManager = this.infrastructure.modeManager;
@@ -295,6 +307,20 @@ export class CodeBuddyAgent extends BaseAgent {
                 catch (err) {
                     logger.debug('Failed to register ContextWarningMiddleware (non-critical)', { error: err instanceof Error ? err.message : String(err) });
                 }
+                // Session duration middleware (priority 35) — suggests a clean pause
+                // with a fresh resume point past CODEBUDDY_SESSION_PAUSE_HOURS (12 h)
+                try {
+                    const { SessionDurationMiddleware } = await import('./middleware/session-duration.js');
+                    pipeline.use(new SessionDurationMiddleware({
+                        takeSnapshot: () => {
+                            this.contextManager.takeSnapshot?.(this.historyManager.getMessagesRef());
+                        },
+                    }));
+                    logger.debug('SessionDurationMiddleware registered in pipeline (priority 35)');
+                }
+                catch (err) {
+                    logger.debug('Failed to register SessionDurationMiddleware (non-critical)', { error: err instanceof Error ? err.message : String(err) });
+                }
                 // Reasoning middleware (priority 42) — auto-detects complex queries
                 try {
                     const { createReasoningMiddleware } = await import('./middleware/reasoning-middleware.js');
@@ -315,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');
@@ -473,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.
@@ -1620,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')
@@ -1637,6 +1690,19 @@ 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')
+                    .then(({ runSessionEndFlush }) => runSessionEndFlush({ chatHistory, client: this.codebuddyClient }))
+                    .catch((err) => {
+                    logger.debug('[session-end-flush] dispose-path flush failed', { error: String(err) });
+                });
+            }
+        }
         // Remove only the forwarding listeners we attached (not other listeners)
         const { start, success, failed, error } = this.repairListeners;
         if (start) {
@@ -1661,8 +1727,30 @@ Look at the screenshot and find the element matching the user's intent. Output o
                 error: err instanceof Error ? err.message : String(err),
             });
         });
+        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
      *