@phuetz/code-buddy 1.1.0 → 1.2.0

package/dist/config/model-tools.js

@@ -405,13 +405,13 @@ const DEFAULT_MODEL_CONFIGS = [
         patchFormat: 'full_file',
         promptProfile: 'lite',
     },
-    // Gemma 4 (Ollama, e2b/e4b) — local lightweight model. Same lite
-    // profile as qwen/llama: minimal SP, no tool_calls advertised,
-    // chat-only base prompt to avoid JSON hallucination on small models.
+    // Gemma 4 (Ollama, e2b/e4b) — local model with tool support. Keep the
+    // lite prompt/tool profile, but do not gate off tool calls: real `buddy goal`
+    // smoke with gemma4:12b only succeeds when the selected tools are preserved.
     {
         model: 'gemma4*',
         supportsReasoning: false,
-        supportsToolCalls: false,
+        supportsToolCalls: true,
         supportsVision: false,
         contextWindow: 8192,
         maxOutputTokens: 2048,

package/dist/config/toml-config.d.ts

@@ -122,6 +122,20 @@ export interface ModelPairsConfig {
     /** Model used for code edits and execution (the "doer") */
     editor?: string;
 }
+/** Active-LLM registry: auto-failover across the user's live logins + "together". */
+export interface LlmFailoverConfig {
+    /** Master gate. OFF by default — single-provider behavior is unchanged. */
+    enabled?: boolean;
+    /** Fallback ordering: 'resilience' (capable/subscription first, local last),
+     * 'free-first' (cheapest first), or 'manual' (explicit `manualOrder`). */
+    order?: 'resilience' | 'free-first' | 'manual';
+    /** Provider ids in preferred order when `order: 'manual'`. */
+    manualOrder?: string[];
+    /** Restrict the active set to local runtimes (privacy). */
+    local_only?: boolean;
+    /** Default strategy for `/llm ensemble` (Phase 2). */
+    together_strategy?: 'ensemble' | 'consensus' | 'fastest' | 'cascade';
+}
 /**
  * External integrations configuration
  */
@@ -497,6 +511,8 @@ export interface CodeBuddyConfig {
     integrations: IntegrationsConfig;
     /** Model pairs for architect/editor split */
     model_pairs?: ModelPairsConfig;
+    /** Active-LLM registry: auto-failover across live logins + "together" */
+    llm?: LlmFailoverConfig;
     /** Agent defaults (model preferences) — Native Engine v2026.3.14 */
     agent_defaults?: AgentDefaultsConfig;
     /** Advisor tool settings (second opinion model) — V4.1 */

package/dist/config/toml-config.js

@@ -540,6 +540,9 @@ class ConfigManager {
         if (partial.model_pairs) {
             this.config.model_pairs = { ...this.config.model_pairs, ...partial.model_pairs };
         }
+        if (partial.llm) {
+            this.config.llm = { ...this.config.llm, ...partial.llm };
+        }
     }
     /**
      * Get current config

package/dist/context/context-manager-v2.js

@@ -699,6 +699,7 @@ export class ContextManagerV2 {
      * Clean up resources
      */
     dispose() {
+        this.stopPeriodicSnapshot();
         this.tokenCounter.dispose();
         this.summaries = [];
         this.triggeredWarnings.clear();

package/dist/daemon/autonomous-daemon.d.ts

@@ -89,7 +89,7 @@ export interface DefaultAutonomousLoopOptions {
  * local/network executor. The CLI uses this so the same config drives one-shot
  * and continuous runs.
  */
-export declare function createDefaultAutonomousLoop(opts?: DefaultAutonomousLoopOptions): FleetAutonomousLoop;
+export declare function createDefaultAutonomousLoop(opts?: DefaultAutonomousLoopOptions): Promise<FleetAutonomousLoop>;
 /**
  * Event source for {@link AutonomousDaemonConfig.eventSourceFactory}: watches the
  * fleet queue file (`colab-tasks.json`) and calls `onChange` when it changes —

package/dist/daemon/autonomous-daemon.js

@@ -13,7 +13,7 @@
  * (see {@link createAgentTaskExecutor}).
  */
 import { FleetColabStore } from '../fleet/colab-store.js';
-import { resolveModelTierConfig } from '../agent/model-tier.js';
+import { resolveLiveModelTierConfig, } from '../agent/model-tier.js';
 import { FileWatcherTrigger } from '../agent/file-watcher-trigger.js';
 import { FleetAutonomousLoop } from './autonomous-loop.js';
 import { createLocalModelTaskExecutor } from './ollama-task-executor.js';
@@ -116,12 +116,12 @@ export class FleetAutonomousDaemon {
  * local/network executor. The CLI uses this so the same config drives one-shot
  * and continuous runs.
  */
-export function createDefaultAutonomousLoop(opts = {}) {
+export async function createDefaultAutonomousLoop(opts = {}) {
     const store = new FleetColabStore({
         ...(opts.dir ? { dir: opts.dir } : {}),
         ...(opts.agentId ? { agentId: opts.agentId } : {}),
     });
-    const tierConfig = resolveModelTierConfig();
+    const tierConfig = await resolveLiveModelTierConfig();
     const executorMode = opts.executorMode ?? (process.env['CODEBUDDY_AUTONOMY_EXECUTOR'] === 'agent' ? 'agent' : 'artifact');
     const executor = executorMode === 'agent'
         ? createAgentTaskExecutor({ ...(opts.workspaceRoot ? { workspaceRoot: opts.workspaceRoot } : {}) })

package/dist/daemon/autonomous-loop.js

@@ -23,6 +23,14 @@
 import { chooseAutonomousModel, } from '../agent/model-tier.js';
 import { beginFleetWork, isFleetSaturated } from '../fleet/fleet-load.js';
 import { DEFAULT_COLAB_GOAL_MAX_TURNS } from './colab-goal.js';
+function resolveGoalMaxTurns(raw) {
+    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw > 0
+        ? raw
+        : DEFAULT_COLAB_GOAL_MAX_TURNS;
+}
+function resolveGoalTurnsUsed(raw) {
+    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0 ? raw : 0;
+}
 export class FleetAutonomousLoop {
     store;
     tierConfig;
@@ -145,11 +153,12 @@ export class FleetAutonomousLoop {
         }
         if (verdict.verdict !== 'continue')
             return null;
-        const maxTurns = task.goalMaxTurns ?? DEFAULT_COLAB_GOAL_MAX_TURNS;
-        const turnsUsed = (task.goalTurnsUsed ?? 0) + 1;
+        const maxTurns = resolveGoalMaxTurns(task.goalMaxTurns);
+        const turnsUsed = resolveGoalTurnsUsed(task.goalTurnsUsed) + 1;
         if (turnsUsed >= maxTurns) {
             // Hermes rule: block for human review instead of spinning forever.
             const reason = `goal budget exhausted (${turnsUsed}/${maxTurns}) — judge: ${verdict.reason}`;
+            this.store.recordGoalTurn(task.id, verdict.reason);
             this.store.blockTask(task.id, reason);
             this.store.appendWorklog({
                 agent: this.store.agentId,

package/dist/daemon/colab-goal.js

@@ -12,6 +12,7 @@
  * "continue", and the turn budget is the backstop.
  */
 import { CodeBuddyClient } from '../codebuddy/client.js';
+import { resolveGoalJudgeClient } from '../goals/goal-judge-client.js';
 import { judgeGoal } from '../goals/goal-judge.js';
 import { resolveGoalsConfig } from '../goals/goal-manager.js';
 import { logger } from '../utils/logger.js';
@@ -54,12 +55,19 @@ export function createColabGoalJudge() {
     return async (task, result, model) => {
         try {
             const config = resolveGoalsConfig();
-            const client = new CodeBuddyClient(process.env.GROK_API_KEY || process.env.OPENAI_API_KEY || 'local', config.judgeModel || model.model, model.baseUrl);
+            const apiKey = process.env.GROK_API_KEY || process.env.OPENAI_API_KEY || 'local';
+            const baseClient = new CodeBuddyClient(apiKey, model.model, model.baseUrl);
+            const client = await resolveGoalJudgeClient(baseClient, config.judgeModel, {
+                apiKey,
+                ...(model.baseUrl ? { baseURL: model.baseUrl } : {}),
+                providerLabel: model.baseUrl?.includes(':11434') ? 'ollama' : model.tier,
+            });
             return await judgeGoal(client, {
                 goal: goalTextForTask(task),
                 lastResponse: result.output || result.summary,
                 ...(task.acceptanceCriteria?.length ? { subgoals: task.acceptanceCriteria } : {}),
                 ...(config.judgeModel ? { model: config.judgeModel } : {}),
+                maxTokens: config.judgeMaxTokens,
                 timeoutMs: config.judgeTimeoutMs,
             });
         }

package/dist/daemon/cron-agent-bridge.d.ts

@@ -40,6 +40,12 @@ export interface JobExecutionResult {
     skipReason?: string;
     /** For watchdog jobs: false when any check produced an alert/error. */
     watchdogOk?: boolean;
+    /**
+     * Structured output data for cross-job data passing. When this job is part
+     * of a chain (`then`), its outputData is forwarded as the next job's
+     * inputData.
+     */
+    outputData?: string;
 }
 export declare class CronAgentBridge extends EventEmitter {
     private config;
@@ -48,11 +54,11 @@ export declare class CronAgentBridge extends EventEmitter {
     /**
      * Create a task executor function for the CronScheduler
      */
-    createTaskExecutor(): (job: CronJob) => Promise<unknown>;
+    createTaskExecutor(): (job: CronJob, inputData?: string) => Promise<unknown>;
     /**
      * Execute a cron job by creating an agent instance
      */
-    executeJob(job: CronJob): Promise<JobExecutionResult>;
+    executeJob(job: CronJob, inputData?: string): Promise<JobExecutionResult>;
     /**
      * Start a durable run record for a job execution, when an observability store
      * is configured. Returns the run id, or undefined when recording is disabled
@@ -86,8 +92,11 @@ export declare class CronAgentBridge extends EventEmitter {
      * WITHOUT instantiating a CodeBuddyAgent or calling any model provider.
      * A non-zero exit (or timeout) throws so the run is recorded as failed and
      * any chained `then` job does not fire.
+     *
+     * Returns both the combined output (for logging/delivery) and the separate
+     * stdout (for cross-job data passing, capped at 64KB by the script runner).
      */
-    private executeScriptTask;
+    private executeScriptTaskFull;
     /**
      * Execute a skill-type task — resolves a named skill from the SkillRegistry
      * and runs it via the SkillExecutor. Without a configured tool executor the

package/dist/daemon/cron-agent-bridge.js

@@ -28,14 +28,14 @@ export class CronAgentBridge extends EventEmitter {
      * Create a task executor function for the CronScheduler
      */
     createTaskExecutor() {
-        return async (job) => {
-            return this.executeJob(job);
+        return async (job, inputData) => {
+            return this.executeJob(job, inputData);
         };
     }
     /**
      * Execute a cron job by creating an agent instance
      */
-    async executeJob(job) {
+    async executeJob(job, inputData) {
         const startTime = Date.now();
         const abortController = new AbortController();
         this.activeJobs.set(job.id, abortController);
@@ -80,9 +80,10 @@ export class CronAgentBridge extends EventEmitter {
             }
             let output;
             let watchdogOk;
+            let scriptStdout;
             switch (job.task.type) {
                 case 'message': {
-                    output = await this.executeMessageTask(job);
+                    output = await this.executeMessageTask(job, inputData);
                     break;
                 }
                 case 'tool': {
@@ -100,7 +101,9 @@ export class CronAgentBridge extends EventEmitter {
                     break;
                 }
                 case 'script': {
-                    output = await this.executeScriptTask(job);
+                    const scriptResult = await this.executeScriptTaskFull(job);
+                    output = scriptResult.output;
+                    scriptStdout = scriptResult.stdout;
                     break;
                 }
                 case 'skill': {
@@ -132,6 +135,10 @@ export class CronAgentBridge extends EventEmitter {
                 deliveryChannel,
                 ...(watchdogOk !== undefined ? { watchdogOk } : {}),
             });
+            // For script jobs, outputData is the captured stdout only (structured
+            // data channel, capped at 64KB in the script runner). For all other
+            // task types, the full output serves as outputData.
+            const outputData = job.task.type === 'script' ? scriptStdout : output;
             const result = {
                 jobId: job.id,
                 runId: recordedRunId ?? `run-${Date.now()}`,
@@ -140,6 +147,7 @@ export class CronAgentBridge extends EventEmitter {
                 duration,
                 delivered,
                 deliveryChannel,
+                outputData,
                 ...(watchdogOk !== undefined ? { watchdogOk } : {}),
             };
             this.emit('job:complete', result);
@@ -223,7 +231,7 @@ export class CronAgentBridge extends EventEmitter {
     /**
      * Execute a message-type task
      */
-    async executeMessageTask(job) {
+    async executeMessageTask(job, inputData) {
         if (!job.task.message) {
             throw new Error('Message task requires a message');
         }
@@ -245,7 +253,12 @@ export class CronAgentBridge extends EventEmitter {
                 logger.debug(`Cron job ${job.id}: could not load session ${job.resolvedSessionId}, starting fresh`);
             }
         }
-        const entries = await agent.processUserMessage(job.task.message);
+        // Prepend inputData from parent chained job if available
+        let message = job.task.message;
+        if (inputData) {
+            message = `[Chained job context — output from parent job]:\n${inputData}\n\n[Task]:\n${message}`;
+        }
+        const entries = await agent.processUserMessage(message);
         const assistantEntries = entries.filter(e => e.type === 'assistant');
         return assistantEntries.map(e => e.content).join('\n') || 'No response';
     }
@@ -292,8 +305,11 @@ export class CronAgentBridge extends EventEmitter {
      * WITHOUT instantiating a CodeBuddyAgent or calling any model provider.
      * A non-zero exit (or timeout) throws so the run is recorded as failed and
      * any chained `then` job does not fire.
+     *
+     * Returns both the combined output (for logging/delivery) and the separate
+     * stdout (for cross-job data passing, capped at 64KB by the script runner).
      */
-    async executeScriptTask(job) {
+    async executeScriptTaskFull(job) {
         const command = job.task.command;
         if (!command || typeof command.executable !== 'string' || command.executable.length === 0) {
             throw new Error('Script task requires a command with an executable');
@@ -312,7 +328,7 @@ export class CronAgentBridge extends EventEmitter {
         if (result.exitCode !== 0) {
             throw new Error(`script failed: ${command.executable} (exit ${result.exitCode})\n${result.output}`.trim());
         }
-        return result.output;
+        return { output: result.output, stdout: result.stdout };
     }
     /**
      * Execute a skill-type task — resolves a named skill from the SkillRegistry

package/dist/desktop/codebuddy-engine-adapter.d.ts

@@ -40,6 +40,12 @@ export declare class CodeBuddyEngineAdapter implements EngineAdapter {
      * effect on the next turn (Phase 8).
      */
     private agentIdentities;
+    /**
+     * Configured reasoning/thinking level (`off | minimal | … | xhigh`), set via
+     * {@link setThinkingLevel}. Re-applied to each freshly-created agent so a
+     * model swap / new session keeps the user's chosen level.
+     */
+    private thinkingLevel?;
     /**
      * Hard cap on cached agents — matches the pi-runner's
      * `MAX_CACHED_SESSIONS` (50) so memory pressure is comparable
@@ -50,6 +56,7 @@ export declare class CodeBuddyEngineAdapter implements EngineAdapter {
     constructor(config: EngineSessionConfig);
     runSession(sessionId: string, messages: EngineMessage[], onEvent: EngineStreamCallback, options?: Partial<EngineSessionConfig>): Promise<EngineSessionResult>;
     cancel(sessionId: string): void;
+    steer(sessionId: string, prompt: string): boolean;
     clearSession(sessionId: string): void;
     /**
      * Drop oldest cached agents until `agents.size <= maxRetained`.
@@ -70,6 +77,21 @@ export declare class CodeBuddyEngineAdapter implements EngineAdapter {
      * returns whatever survived the previous load.
      */
     reloadSkills(): Promise<void>;
+    /**
+     * Hot-swap the reasoning/thinking level for live sessions. Updates the global
+     * extended-thinking budget (read per-turn by the OpenAI-compat / Grok / Ollama
+     * providers → effective next turn, no rebuild) and the Gemini-native default on
+     * every cached agent. The level is remembered so future agents inherit it.
+     */
+    setThinkingLevel(level: string): Promise<void>;
+    /**
+     * Map a UI level to the Gemini-native default thinking level on a single
+     * agent's client. `GeminiThinkingLevel` is `minimal|low|medium|high`, so
+     * `xhigh` clamps to `high` and `off`/unknown leaves the Gemini default
+     * untouched (the global extended-thinking switch already disables it for the
+     * OpenAI-compat path). Best-effort; never throws.
+     */
+    private applyGeminiThinkingLevel;
     /**
      * Synchronise the core MCPManager singleton with the host's view of
      * the MCP servers. Called by Cowork at boot and after any
@@ -97,3 +119,13 @@ export declare class CodeBuddyEngineAdapter implements EngineAdapter {
      */
     updateConfig(config: Partial<EngineSessionConfig>): void;
 }
+/** Cap a single failure detail so the footer stays compact for the judge. */
+export declare function truncateFailureDetail(detail: string, max?: number): string;
+/**
+ * Build a prominent, NON-bracketed footer listing failed tool actions. The goal
+ * judge prompt (goal-state.ts) treats `[tool:…]` bracketed lines as ignorable
+ * metadata, so failures must be surfaced as a plain instruction line or the
+ * judge discounts them. Returns '' when there are no failures.
+ */
+export declare function buildToolFailureFooter(failures: string[]): string;
+export declare function buildGoalJudgeResponse(content: string, toolEvidence: string[], toolFailures?: string[]): string;