@phuetz/code-buddy 1.1.0 → 1.3.0

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.

package/dist/agent/extended-thinking.js

@@ -67,6 +67,33 @@ export class ExtendedThinkingManager {
         this.alwaysEnabled = value;
         logger.info(`Extended thinking always-enabled: ${value}`);
     }
+    /**
+     * 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) {
+        const budgets = {
+            minimal: 1024,
+            low: 2048,
+            medium: 4096,
+            high: 8192,
+            xhigh: 16384,
+        };
+        const budget = budgets[level];
+        if (budget === undefined) {
+            this.enabled = false;
+            this.alwaysEnabled = false;
+            logger.info(`Extended thinking disabled (level=${level})`);
+            return;
+        }
+        this.maxThinkingTokens = budget;
+        this.enabled = false; // the configured level drives state via alwaysEnabled
+        this.alwaysEnabled = true;
+        logger.info(`Extended thinking level=${level} (budget: ${budget} tokens)`);
+    }
     /**
      * 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.

package/dist/agent/facades/infrastructure-facade.d.ts

@@ -77,11 +77,18 @@ export declare class InfrastructureFacade {
      * Get the MCP client instance (for advanced operations)
      */
     getMCPClient(): MCPClient;
+    /** Resolves once initializeMCP() has finished connecting servers (or failed
+     * softly). Callers that need MCP tools available — notably headless one-shot
+     * runs — can await getMCPReady() instead of racing the fire-and-forget init. */
+    private mcpReady;
     /**
-     * Initialize MCP servers asynchronously
-     * This is a fire-and-forget operation
+     * Initialize MCP servers asynchronously. Kicks off in the background (the
+     * constructor path stays non-blocking), but the readiness promise is captured
+     * so a one-shot/headless caller can await getMCPReady() before its first turn.
      */
     initializeMCP(): void;
+    /** Promise that resolves when MCP server initialization has settled. */
+    getMCPReady(): Promise<void>;
     /**
      * Get the ICM bridge instance for memory operations
      */

package/dist/agent/facades/infrastructure-facade.js

@@ -67,12 +67,17 @@ export class InfrastructureFacade {
     getMCPClient() {
         return this.mcpClient;
     }
+    /** Resolves once initializeMCP() has finished connecting servers (or failed
+     * softly). Callers that need MCP tools available — notably headless one-shot
+     * runs — can await getMCPReady() instead of racing the fire-and-forget init. */
+    mcpReady = Promise.resolve();
     /**
-     * Initialize MCP servers asynchronously
-     * This is a fire-and-forget operation
+     * Initialize MCP servers asynchronously. Kicks off in the background (the
+     * constructor path stays non-blocking), but the readiness promise is captured
+     * so a one-shot/headless caller can await getMCPReady() before its first turn.
      */
     initializeMCP() {
-        (async () => {
+        this.mcpReady = (async () => {
             try {
                 const config = loadMCPConfig();
                 if (config.servers.length > 0) {
@@ -87,9 +92,13 @@ export class InfrastructureFacade {
             catch (error) {
                 logger.warn('MCP initialization failed', { error: getErrorMessage(error) });
             }
-        })().catch((error) => {
-            logger.warn('Uncaught error in MCP initialization', { error: getErrorMessage(error) });
-        });
+        })();
+        // Never let this become an unhandled rejection for callers that don't await.
+        void this.mcpReady.catch(() => { });
+    }
+    /** Promise that resolves when MCP server initialization has settled. */
+    getMCPReady() {
+        return this.mcpReady;
     }
     /**
      * Get the ICM bridge instance for memory operations

package/dist/agent/hermes-browser-backends.js

@@ -10,6 +10,8 @@ import { spawnSync } from 'child_process';
 import { mkdir, mkdtemp, stat } from 'fs/promises';
 import { tmpdir } from 'os';
 import { isAbsolute, join, resolve } from 'path';
+import { executeBrowserUseAction } from '../browser-automation/browser-use-runner.js';
+import { closeCamofox, launchCamofox } from '../browser-automation/camofox-runner.js';
 const require = createRequire(import.meta.url);
 function presentEnvKeys(env, keys) {
     return keys.filter((key) => Boolean(env[key]?.trim()));
@@ -143,15 +145,17 @@ function browserUseBackend(env) {
         label: 'Browser Use gateway',
         officialSurface: 'Browser Use managed browser mode',
         status: configured ? 'configured' : 'missing',
-        installed: false,
+        installed: true,
         configured,
-        runnable: false,
+        runnable: configured,
         command: null,
         version: null,
         credentialSources,
-        smokeCommand: null,
-        notes: ['Tracked for Hermes parity; Code Buddy does not yet expose a first-class Browser Use runtime runner.'],
-        remediation: ['Use local Playwright today, or wire the Nous Tool Gateway before claiming Browser Use backend parity.'],
+        smokeCommand: configured ? 'buddy hermes browser-smoke browser-use --json' : null,
+        notes: ['Browser Use runner routes actions through the Browser Use API or Nous Tool Gateway (src/browser-automation/browser-use-runner.ts).'],
+        remediation: configured
+            ? []
+            : ['Set BROWSER_USE_API_KEY or CODEBUDDY_NOUS_TOOL_GATEWAY_URL to enable the Browser Use backend.'],
     };
 }
 function firecrawlBackend(env) {
@@ -184,13 +188,13 @@ function camofoxBackend(env) {
         status: installed ? 'available' : 'missing',
         installed,
         configured: installed,
-        runnable: false,
+        runnable: installed,
         command: installed ? (camofox.ok ? 'camofox' : 'camoufox') : null,
         version: installed ? firstLine(camoufox.output) : null,
         credentialSources: [],
-        smokeCommand: null,
-        notes: ['Detected only as an optional upstream-compatible backend; no Code Buddy runner is wired yet.'],
-        remediation: installed ? ['Wire a first-class runner before claiming Camofox parity.'] : ['Install Camofox/Camoufox only if this backend is required.'],
+        smokeCommand: installed ? 'buddy hermes browser-smoke camofox --json' : null,
+        notes: ['Camofox runner launches the anti-detect Firefox Playwright server and connects via firefox.connect() (src/browser-automation/camofox-runner.ts).'],
+        remediation: installed ? [] : ['Install Camofox/Camoufox only if this backend is required.'],
     };
 }
 function recordingBackend() {
@@ -271,13 +275,13 @@ function browserRouteGateReason(backend) {
         return 'Browserbase is configured but excluded from auto browser routing; use the explicit smoke runner for managed sessions.';
     }
     if (backend.id === 'browser-use' && backend.configured) {
-        return 'Browser Use is configured but excluded from auto browser routing until the Nous Tool Gateway runner is wired.';
+        return null; // Browser Use runner is wired — eligible for auto-routing.
     }
     if (backend.id === 'firecrawl' && backend.configured) {
         return 'Firecrawl is configured but excluded from auto browser routing because it is an extraction backend, not an interactive browser session.';
     }
     if (backend.id === 'camofox' && backend.installed) {
-        return 'Camofox/Camoufox is installed but excluded from auto browser routing until a first-class runner exists.';
+        return null; // Camofox runner is wired — eligible for auto-routing.
     }
     return null;
 }
@@ -538,6 +542,136 @@ async function runBrowserbaseSmoke(now, env) {
         }
     }
 }
+async function runBrowserUseSmoke(now, env) {
+    const started = now();
+    const startedAtMs = Date.now();
+    const apiKey = env.BROWSER_USE_API_KEY?.trim();
+    const gatewayUrl = env.CODEBUDDY_NOUS_TOOL_GATEWAY_URL?.trim();
+    if (!apiKey && !gatewayUrl) {
+        return {
+            backendId: 'browser-use',
+            command: null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Browser Use gateway',
+            ok: false,
+            output: 'BROWSER_USE_API_KEY or CODEBUDDY_NOUS_TOOL_GATEWAY_URL is required for browser-use smoke.',
+            startedAt: started.toISOString(),
+            status: 'not-runnable',
+            stdout: '',
+            stderr: 'BROWSER_USE_API_KEY or CODEBUDDY_NOUS_TOOL_GATEWAY_URL is required for browser-use smoke.',
+        };
+    }
+    const result = await executeBrowserUseAction('Open the page and report the title or main heading.', 'https://example.com', {
+        apiKey,
+        gatewayUrl,
+        timeout: 60_000,
+    });
+    const output = result.content ?? (result.screenshot ? 'Browser Use returned screenshot data.' : '');
+    return {
+        backendId: 'browser-use',
+        command: null,
+        durationMs: Math.max(0, Date.now() - startedAtMs),
+        finishedAt: now().toISOString(),
+        label: 'Browser Use gateway',
+        ok: result.ok,
+        output: result.ok ? output : result.error ?? 'Browser Use smoke failed.',
+        startedAt: started.toISOString(),
+        status: result.ok ? 'passed' : 'failed',
+        stdout: result.ok ? output : '',
+        stderr: result.ok ? '' : result.error ?? 'Browser Use smoke failed.',
+    };
+}
+async function runCamofoxSmoke(now, env) {
+    const started = now();
+    const startedAtMs = Date.now();
+    const binaryPath = env.CODEBUDDY_CAMOFOX_BINARY?.trim() || undefined;
+    const pythonPath = env.CODEBUDDY_CAMOFOX_PYTHON?.trim() || undefined;
+    // Camoufox is Firefox: launch its Playwright server and connect via
+    // firefox.connect() — NOT chromium.connectOverCDP(). The launch step returns
+    // a Playwright-server wsEndpoint; the connect below proves the repo's pinned
+    // Playwright can actually drive it (this is where the version-lock, if any,
+    // surfaces honestly rather than being faked as success on the endpoint alone).
+    const result = await launchCamofox({
+        binaryPath,
+        pythonPath,
+        headless: true,
+        timeout: 30_000,
+    });
+    if (!result.ok) {
+        const message = result.error ?? 'Camofox smoke failed.';
+        return {
+            backendId: 'camofox',
+            command: binaryPath ?? pythonPath ?? null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Camofox / Camoufox',
+            ok: false,
+            output: message,
+            startedAt: started.toISOString(),
+            status: /not (found|importable)|No module named/i.test(message) ? 'not-runnable' : 'failed',
+            stdout: '',
+            stderr: message,
+        };
+    }
+    const wsEndpoint = result.wsEndpoint;
+    let browser = null;
+    let context = null;
+    try {
+        const playwright = await import('playwright');
+        browser = await playwright.firefox.connect(wsEndpoint);
+        context = await browser.newContext();
+        const page = await context.newPage();
+        await page.goto('data:text/html,<title>OK-HERMES-CAMOFOX</title><h1>OK-HERMES-CAMOFOX</h1>', {
+            waitUntil: 'domcontentloaded',
+        });
+        const title = await page.title();
+        const heading = await page.locator('h1').textContent();
+        const ok = title === 'OK-HERMES-CAMOFOX' && heading === 'OK-HERMES-CAMOFOX';
+        const output = `title=${title}; heading=${heading ?? ''}; pid=${result.pid ?? 'unknown'}`;
+        return {
+            backendId: 'camofox',
+            command: binaryPath ?? pythonPath ?? null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Camofox / Camoufox',
+            ok,
+            output,
+            startedAt: started.toISOString(),
+            status: ok ? 'passed' : 'failed',
+            stdout: ok ? output : '',
+            stderr: ok ? '' : 'Unexpected Camofox page content.',
+            // Never expose the host:port wsEndpoint in the result.
+            session: { url: 'camoufox-firefox-server' },
+        };
+    }
+    catch (error) {
+        // A Playwright version-guard mismatch (server driver vs repo client) lands
+        // here. Report it honestly as a failure with the connect error message —
+        // do not fall back to a fake success.
+        const message = errorMessage(error);
+        return {
+            backendId: 'camofox',
+            command: binaryPath ?? pythonPath ?? null,
+            durationMs: Math.max(0, Date.now() - startedAtMs),
+            finishedAt: now().toISOString(),
+            label: 'Camofox / Camoufox',
+            ok: false,
+            output: message,
+            startedAt: started.toISOString(),
+            status: 'failed',
+            stdout: '',
+            stderr: message,
+        };
+    }
+    finally {
+        await context?.close().catch(() => undefined);
+        await browser?.close().catch(() => undefined);
+        if (result.pid) {
+            await closeCamofox(result.pid).catch(() => undefined);
+        }
+    }
+}
 async function runLocalPlaywrightSmoke(now, options = {}) {
     const started = now();
     const startedAtMs = Date.now();
@@ -700,6 +834,12 @@ export async function runHermesBrowserBackendSmoke(options) {
     if (backend.id === 'browserbase') {
         return runBrowserbaseSmoke(now, env);
     }
+    if (backend.id === 'browser-use') {
+        return runBrowserUseSmoke(now, env);
+    }
+    if (backend.id === 'camofox') {
+        return runCamofoxSmoke(now, env);
+    }
     if (!backend.runnable) {
         return blockedSmokeResult(backend.id, 'not-runnable', `${backend.label} is not runnable on this host.`, {
             backend,

package/dist/agent/hermes-claw-migrate.d.ts

@@ -100,6 +100,65 @@ export interface ClawAgentBehaviorSettings {
  * are mapped; everything else stays archived for manual review.
  */
 export declare function mapClawAgentBehavior(cfg: Record<string, unknown>): ClawAgentBehaviorSettings;
+/**
+ * Cron job entry as translated from an OpenClaw `cronJobs` array element into
+ * the shape consumed by CronScheduler.addJob().
+ */
+export interface ClawCronJobEntry {
+    name: string;
+    schedule: string;
+    task: string;
+}
+/**
+ * Map OpenClaw cron config to a list of CronJob-compatible entries.
+ *
+ * OpenClaw stores cron jobs as an array of `{ schedule, task, label? }` objects
+ * or — in 2026.6.x — under `scheduler.jobs`. Only entries with both a valid
+ * 5-field cron expression and a non-empty task string are mapped. Everything
+ * else is silently dropped (will remain in the archived raw slice if one
+ * exists).
+ */
+export declare function mapClawCronJobs(cfg: Record<string, unknown>): ClawCronJobEntry[];
+/**
+ * Map OpenClaw command allowlist into a flat string array of allowed command
+ * basenames / patterns, consumable by Code Buddy's command validator.
+ *
+ * OpenClaw stores these as a flat string array under `commandAllowlist`,
+ * `allowlist`, or `allowedCommands`. Items that look like credentials or paths
+ * outside of simple command names are filtered out.
+ */
+export declare function mapClawCommandAllowlist(cfg: Record<string, unknown>): string[];
+/**
+ * Map OpenClaw memory backend config to a Code Buddy memory provider name.
+ *
+ * Only well-known provider names are accepted; unknown strings are left
+ * unmapped (will stay in the archive). Credentials (API keys, URLs) in the
+ * memory backend config are never imported.
+ */
+export declare function mapClawMemoryBackend(cfg: Record<string, unknown>): string | undefined;
+/**
+ * Map OpenClaw exec timeout to a numeric millisecond value for Code Buddy's
+ * `execTimeout` setting.
+ *
+ * OpenClaw stores this as seconds (integer) or milliseconds (large integer).
+ * Values ≤ 0 are ignored. Values that look like seconds (≤ 3600) are
+ * multiplied by 1000. Clamped to a maximum of 3600000 ms (1 hour).
+ */
+export declare function mapClawExecTimeout(cfg: Record<string, unknown>): number | undefined;
+/**
+ * Vision config fields that Code Buddy consumes.
+ */
+export interface ClawVisionSettings {
+    visionEnabled?: boolean;
+    visionModel?: string;
+}
+/**
+ * Map OpenClaw vision settings to Code Buddy's vision config keys.
+ *
+ * Only the `enabled` boolean and `model` string are imported. Provider
+ * credentials, endpoint URLs, and other complex fields are left archived.
+ */
+export declare function mapClawVisionSettings(cfg: Record<string, unknown>): ClawVisionSettings;
 /** Build the migration plan (read-only; no writes). */
 export declare function buildClawMigrationPlan(opts?: ClawMigrationOptions): ClawMigrationEntry[];
 /**