@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/config/feature-flags.js

@@ -56,6 +56,13 @@ const DEFAULT_FEATURE_FLAGS = {
         category: 'ai',
         envOverride: 'USER_MODEL_DIALECTIC_ON_SESSION_END',
     },
+    SESSION_END_FLUSH: {
+        name: 'SESSION_END_FLUSH',
+        enabled: true,
+        description: 'At session end, write a short handoff (.codebuddy/HANDOFF.md) and propose review-gated lesson candidates from the transcript (WS3-T1)',
+        category: 'ai',
+        envOverride: 'CODEBUDDY_SESSION_END_FLUSH',
+    },
     VOICE_CONTROL: {
         name: 'VOICE_CONTROL',
         enabled: false,

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.d.ts

@@ -60,6 +60,23 @@ export interface ContextStats {
     isNearLimit: boolean;
     isCritical: boolean;
 }
+/**
+ * Periodic memory snapshot (WS3-T2) — a compact, persisted view of the
+ * session so very long runs (12–15 h) survive crashes and aggressive
+ * compaction without losing the thread.
+ */
+export interface ContextSnapshot {
+    sessionId: string;
+    takenAt: string;
+    stats: {
+        messageCount: number;
+        tokenCount: number;
+        compressionCount: number;
+        totalTokensSaved: number;
+    };
+    /** Extractive, privacy-linted summary of the conversation so far. */
+    summary: string;
+}
 /**
  * Memory metrics for monitoring context manager health
  */
@@ -125,6 +142,10 @@ export declare class ContextManagerV2 {
     private _cachedStatsFingerprint;
     /** Last compression timestamp */
     private lastCompressionTime;
+    /** WS3-T2 — periodic snapshot timer (unref'd, never keeps the process alive) */
+    private snapshotTimer;
+    /** WS3-T2 — snapshots taken this session */
+    private snapshotCount;
     static readonly DEFAULT_CONFIG: ContextManagerConfig;
     constructor(config?: Partial<ContextManagerConfig>);
     /**
@@ -344,6 +365,24 @@ export declare class ContextManagerV2 {
      * Format compression statistics as human-readable string
      */
     formatCompressionStats(): string;
+    /**
+     * Take a compact snapshot of the session and persist it to
+     * `.codebuddy/context-snapshot.json` (latest wins). Returns null when the
+     * conversation is too small to be worth snapshotting.
+     *
+     * The summary is privacy-linted before it touches disk (WS3 guard-rail).
+     */
+    takeSnapshot(messages: CodeBuddyMessage[], workDir?: string): ContextSnapshot | null;
+    /**
+     * Start the periodic snapshot loop for long sessions (12–15 h).
+     *
+     * Interval resolution: explicit param → `CODEBUDDY_SNAPSHOT_INTERVAL_MIN`
+     * env (minutes) → 45 min default. `0` (or negative) disables. The timer
+     * is unref'd so it never keeps a finished process alive.
+     */
+    startPeriodicSnapshot(getMessages: () => CodeBuddyMessage[], intervalMs?: number, workDir?: string): void;
+    /** Stop the periodic snapshot loop (idempotent). */
+    stopPeriodicSnapshot(): void;
 }
 export type { KeyInformation, ContextArchive, CompressionMetrics, EnhancedCompressionResult, };
 /**

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

@@ -12,6 +12,9 @@
  * - Content-type-aware Compression
  * - Key Information Preservation
  */
+import * as fs from 'fs';
+import * as path from 'path';
+import { redactSecrets } from '../fleet/privacy-lint.js';
 import { createTokenCounter } from './token-counter.js';
 import { logger } from '../utils/logger.js';
 import { getModelToolConfig } from '../config/model-tools.js';
@@ -74,6 +77,10 @@ export class ContextManagerV2 {
     _cachedStatsFingerprint = '';
     /** Last compression timestamp */
     lastCompressionTime = null;
+    /** WS3-T2 — periodic snapshot timer (unref'd, never keeps the process alive) */
+    snapshotTimer = null;
+    /** WS3-T2 — snapshots taken this session */
+    snapshotCount = 0;
     // Default configuration based on research recommendations
     static DEFAULT_CONFIG = {
         maxContextTokens: 4096,
@@ -692,6 +699,7 @@ export class ContextManagerV2 {
      * Clean up resources
      */
     dispose() {
+        this.stopPeriodicSnapshot();
         this.tokenCounter.dispose();
         this.summaries = [];
         this.triggeredWarnings.clear();
@@ -921,6 +929,89 @@ export class ContextManagerV2 {
         }
         return lines.join('\n');
     }
+    // ==========================================================================
+    // WS3-T2 — Periodic memory snapshot
+    // ==========================================================================
+    /**
+     * Take a compact snapshot of the session and persist it to
+     * `.codebuddy/context-snapshot.json` (latest wins). Returns null when the
+     * conversation is too small to be worth snapshotting.
+     *
+     * The summary is privacy-linted before it touches disk (WS3 guard-rail).
+     */
+    takeSnapshot(messages, workDir = process.cwd()) {
+        if (!messages || messages.length < 4)
+            return null;
+        const snapshot = {
+            sessionId: this.sessionId,
+            takenAt: new Date().toISOString(),
+            stats: {
+                messageCount: messages.length,
+                tokenCount: this.countTokens(messages),
+                compressionCount: this.compressionCount,
+                totalTokensSaved: this.totalTokensSaved,
+            },
+            summary: redactSecrets(this.createSummary(messages)),
+        };
+        try {
+            const dir = path.join(workDir, '.codebuddy');
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, 'context-snapshot.json'), JSON.stringify(snapshot, null, 2), 'utf8');
+        }
+        catch (err) {
+            logger.debug('Context snapshot write failed', { error: String(err) });
+            return null;
+        }
+        this.snapshotCount++;
+        try {
+            const runStore = RunStore.getInstance();
+            if (runStore.getCurrentRunId()) {
+                runStore.appendEvent('context_snapshot', {
+                    sessionId: snapshot.sessionId,
+                    messageCount: snapshot.stats.messageCount,
+                    tokenCount: snapshot.stats.tokenCount,
+                    snapshotCount: this.snapshotCount,
+                });
+            }
+        }
+        catch {
+            // Observability must never break the snapshot path.
+        }
+        return snapshot;
+    }
+    /**
+     * Start the periodic snapshot loop for long sessions (12–15 h).
+     *
+     * Interval resolution: explicit param → `CODEBUDDY_SNAPSHOT_INTERVAL_MIN`
+     * env (minutes) → 45 min default. `0` (or negative) disables. The timer
+     * is unref'd so it never keeps a finished process alive.
+     */
+    startPeriodicSnapshot(getMessages, intervalMs, workDir = process.cwd()) {
+        this.stopPeriodicSnapshot();
+        let resolved = intervalMs;
+        if (resolved === undefined) {
+            const envMin = parseInt(process.env.CODEBUDDY_SNAPSHOT_INTERVAL_MIN || '45', 10);
+            resolved = (Number.isFinite(envMin) ? envMin : 45) * 60_000;
+        }
+        if (!resolved || resolved <= 0)
+            return;
+        this.snapshotTimer = setInterval(() => {
+            try {
+                this.takeSnapshot(getMessages(), workDir);
+            }
+            catch (err) {
+                logger.debug('Periodic context snapshot failed', { error: String(err) });
+            }
+        }, resolved);
+        this.snapshotTimer.unref();
+    }
+    /** Stop the periodic snapshot loop (idempotent). */
+    stopPeriodicSnapshot() {
+        if (this.snapshotTimer) {
+            clearInterval(this.snapshotTimer);
+            this.snapshotTimer = null;
+        }
+    }
 }
 /**
  * Create a context manager with auto-detection of model limits

package/dist/daemon/agent-task-executor.js

@@ -34,6 +34,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { spawnSync } from 'child_process';
+import { buildColabGoalContinuationPrompt } from './colab-goal.js';
+/** Tail of agent stdout kept for the goal-mode judge (matches the judge's 4 KB cap). */
+const OUTPUT_TAIL_CHARS = 4000;
 /** Resolve the buddy CLI entrypoint inside `repoRoot`. */
 function resolveEntrypoint(repoRoot) {
     const tsx = path.join(repoRoot, 'node_modules', '.bin', 'tsx');
@@ -82,7 +85,11 @@ export function createAgentTaskExecutor(opts = {}) {
         if (!entry) {
             return { ok: false, summary: 'no buddy entrypoint', error: `no src/index.ts or dist/index.js under ${repoRoot}` };
         }
-        const prompt = `${task.title}\n\n${task.description ?? ''}`.trim();
+        // Goal-mode continuation: on later turns the worker gets the judge's
+        // nudge instead of the bare task text, so it targets the remaining gap.
+        const prompt = task.goalMode && (task.goalTurnsUsed ?? 0) > 0
+            ? buildColabGoalContinuationPrompt(task)
+            : `${task.title}\n\n${task.description ?? ''}`.trim();
         const env = buildAgentEnv(model);
         const started = Date.now();
         const res = doSpawn(entry.cmd, [...entry.baseArgs, '-p', prompt, '--permission-mode', permissionMode, '--output-format', 'text', ...extraArgs], { cwd: workspaceRoot, env, encoding: 'utf-8', timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
@@ -99,6 +106,8 @@ export function createAgentTaskExecutor(opts = {}) {
                 error: reason,
             };
         }
+        // Tail of the agent's real output — what the goal-mode judge evaluates.
+        const output = (res.stdout ?? '').slice(-OUTPUT_TAIL_CHARS).trim();
         // Acceptance gate: if the task carries a verify command AND running task-
         // supplied shell is allowed (opt-in), the agent "finishing" isn't enough —
         // the gate must pass for the task to count as completed. When not allowed,
@@ -126,6 +135,7 @@ export function createAgentTaskExecutor(opts = {}) {
                 ok: true,
                 summary: `agent ran ${task.id} [${model.tier}/${model.model}] + gate \`${gate}\` passed (${elapsedSeconds}s)`,
                 elapsedSeconds,
+                ...(output ? { output } : {}),
             };
         }
         const elapsedSeconds = Math.round((Date.now() - started) / 1000);
@@ -133,6 +143,7 @@ export function createAgentTaskExecutor(opts = {}) {
             ok: true,
             summary: `agent ran ${task.id} [${model.tier}/${model.model}] in ${workspaceRoot} (${elapsedSeconds}s)`,
             elapsedSeconds,
+            ...(output ? { output } : {}),
         };
     };
 }

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,11 +13,12 @@
  * (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';
 import { createAgentTaskExecutor } from './agent-task-executor.js';
+import { createColabGoalJudge } from './colab-goal.js';
 const DEFAULT_INTERVAL_MS = 30_000;
 export class FleetAutonomousDaemon {
     loop;
@@ -115,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 } : {}) })
@@ -132,6 +133,7 @@ export function createDefaultAutonomousLoop(opts = {}) {
         store,
         tierConfig,
         executor,
+        goalJudge: createColabGoalJudge(),
         ...(opts.policy ? { policy: opts.policy } : {}),
         ...(opts.enabled ? { enabled: opts.enabled } : {}),
     });

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

@@ -22,12 +22,19 @@
  */
 import { type AutonomousModelChoice, type ModelTierConfig, type ModelTierPolicy } from '../agent/model-tier.js';
 import type { ColabTask, ColabWorklogFileChange, FleetColabStore } from '../fleet/colab-store.js';
+import { type ColabGoalJudge } from './colab-goal.js';
 export interface TaskExecutionResult {
     ok: boolean;
     summary: string;
     filesModified?: ColabWorklogFileChange[];
     elapsedSeconds?: number;
     error?: string;
+    /**
+     * Tail of the worker's actual output (capped). Goal-mode judges evaluate
+     * this; absent for executors that don't capture output (judge falls back
+     * to `summary`).
+     */
+    output?: string;
 }
 export type TaskExecutor = (task: ColabTask, model: AutonomousModelChoice) => Promise<TaskExecutionResult>;
 export interface AutonomousLoopConfig {
@@ -37,9 +44,14 @@ export interface AutonomousLoopConfig {
     policy?: ModelTierPolicy;
     /** Kill-switch — when it returns false the tick is a no-op. Default: always on. */
     enabled?: () => boolean;
+    /**
+     * Judge for `goalMode` tasks (Hermes kanban goal-mode parity). When absent,
+     * goal-mode tasks complete like plain tasks (no judge gate).
+     */
+    goalJudge?: ColabGoalJudge;
 }
 export interface TickResult {
-    outcome: 'disabled' | 'idle' | 'completed' | 'failed' | 'saturated';
+    outcome: 'disabled' | 'idle' | 'completed' | 'failed' | 'saturated' | 'goal_continue' | 'goal_blocked';
     taskId?: string;
     taskTitle?: string;
     model?: AutonomousModelChoice;
@@ -58,7 +70,15 @@ export declare class FleetAutonomousLoop {
      * success. Resets across process restarts — escalation is a within-run feature.
      */
     private readonly failures;
+    private readonly goalJudge;
     constructor(config: AutonomousLoopConfig);
     /** Run a single autonomous tick. Never throws — failures are logged + reported. */
     tick(): Promise<TickResult>;
+    /**
+     * Goal-mode decision ladder. Returns a TickResult when the loop should NOT
+     * complete the task (judge says continue / budget exhausted), or null when
+     * the task may complete (judge done/skipped, or judge unreachable —
+     * fail-open like the interactive Ralph loop).
+     */
+    private evaluateGoalModeTask;
 }

package/dist/daemon/autonomous-loop.js

@@ -22,6 +22,15 @@
  */
 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;
@@ -35,12 +44,14 @@ export class FleetAutonomousLoop {
      * success. Resets across process restarts — escalation is a within-run feature.
      */
     failures = new Map();
+    goalJudge;
     constructor(config) {
         this.store = config.store;
         this.tierConfig = config.tierConfig;
         this.executor = config.executor;
         this.policy = config.policy ?? {};
         this.enabled = config.enabled ?? (() => true);
+        this.goalJudge = config.goalJudge;
     }
     /** Run a single autonomous tick. Never throws — failures are logged + reported. */
     async tick() {
@@ -88,6 +99,14 @@ export class FleetAutonomousLoop {
             doneLoad();
         }
         if (result.ok) {
+            // Goal-mode gate (Hermes kanban goal-mode): a successful attempt is not
+            // enough — the judge must confirm the task's criteria are satisfied.
+            if (task.goalMode && this.goalJudge) {
+                const goalOutcome = await this.evaluateGoalModeTask(task, result, model);
+                if (goalOutcome)
+                    return goalOutcome;
+                // null → judge said done (or skipped): fall through to completion.
+            }
             this.failures.delete(task.id);
             this.store.completeTask(task.id, {
                 summary: result.summary,
@@ -118,5 +137,55 @@ export class FleetAutonomousLoop {
             ...(result.error ? { detail: result.error } : {}),
         };
     }
+    /**
+     * Goal-mode decision ladder. Returns a TickResult when the loop should NOT
+     * complete the task (judge says continue / budget exhausted), or null when
+     * the task may complete (judge done/skipped, or judge unreachable —
+     * fail-open like the interactive Ralph loop).
+     */
+    async evaluateGoalModeTask(task, result, model) {
+        let verdict;
+        try {
+            verdict = await this.goalJudge(task, result, model);
+        }
+        catch {
+            return null; // fail-open: an unusable judge never blocks completion
+        }
+        if (verdict.verdict !== 'continue')
+            return null;
+        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,
+                taskId: task.id,
+                summary: `Goal-mode blocked after ${turnsUsed}/${maxTurns} turns: ${verdict.reason}`,
+                filesModified: result.filesModified ?? [],
+                issues: [reason],
+                nextSteps: ['human review: unblock, split, or complete the task manually'],
+            });
+            this.store.updatePresence({ status: 'idle', currentTask: null });
+            return { outcome: 'goal_blocked', taskId: task.id, taskTitle: task.title, model, detail: verdict.reason };
+        }
+        // Under budget: persist the consumed turn + reason, release the task so a
+        // later tick continues it with the continuation nudge. A judge "continue"
+        // is NOT an executor failure — the model ladder must not escalate.
+        this.store.recordGoalTurn(task.id, verdict.reason);
+        this.store.appendWorklog({
+            agent: this.store.agentId,
+            taskId: task.id,
+            summary: `Goal-mode turn ${turnsUsed}/${maxTurns} — judge: continue: ${verdict.reason}`,
+            filesModified: result.filesModified ?? [],
+            issues: [],
+            nextSteps: ['continue on a later tick with the goal continuation nudge'],
+        });
+        this.store.releaseTask(task.id);
+        this.store.updatePresence({ status: 'idle', currentTask: null });
+        return { outcome: 'goal_continue', taskId: task.id, taskTitle: task.title, model, detail: verdict.reason };
+    }
 }
 //# sourceMappingURL=autonomous-loop.js.map

package/dist/daemon/colab-goal.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Goal-mode for fleet colab tasks — port of Hermes Agent's kanban goal-mode.
+ *
+ * A task with `goalMode: true` is not completed on the worker's first
+ * successful attempt: an LLM judge checks the task's title/description (with
+ * `acceptanceCriteria` as strict numbered criteria) against the worker's
+ * output. "Continue" re-opens the task with a continuation nudge so the next
+ * tick keeps going; once `goalMaxTurns` is spent the task is BLOCKED for
+ * human review instead of spinning (Hermes' "block instead of loop" rule).
+ *
+ * The judge is fail-open (judgeGoal semantics): a broken judge yields
+ * "continue", and the turn budget is the backstop.
+ */
+import type { ColabTask } from '../fleet/colab-store.js';
+import { GoalJudgeResult } from '../goals/goal-judge.js';
+import type { AutonomousModelChoice } from '../agent/model-tier.js';
+import type { TaskExecutionResult } from './autonomous-loop.js';
+/**
+ * Conservative default for unattended subprocess loops (Hermes' kanban
+ * example uses 7; interactive /goal uses 20).
+ */
+export declare const DEFAULT_COLAB_GOAL_MAX_TURNS = 5;
+export type ColabGoalJudge = (task: ColabTask, result: TaskExecutionResult, model: AutonomousModelChoice) => Promise<GoalJudgeResult>;
+/** The goal text the judge evaluates: title + description. */
+export declare function goalTextForTask(task: Pick<ColabTask, 'title' | 'description'>): string;
+/**
+ * Continuation nudge fed to the worker on later goal-mode turns (port of
+ * Hermes' KANBAN_GOAL_CONTINUATION_TEMPLATE, adapted to the colab lifecycle:
+ * completion is decided by the loop's judge, so the worker is nudged to
+ * finish and state the outcome explicitly).
+ */
+export declare function buildColabGoalContinuationPrompt(task: ColabTask): string;
+/**
+ * Default judge: a one-shot call on the same tier model the worker ran on
+ * (local tiers stay free), overridable via `goals.judgeModel`. Task
+ * `acceptanceCriteria` become strict numbered criteria for the judge.
+ */
+export declare function createColabGoalJudge(): ColabGoalJudge;

package/dist/daemon/colab-goal.js

@@ -0,0 +1,81 @@
+/**
+ * Goal-mode for fleet colab tasks — port of Hermes Agent's kanban goal-mode.
+ *
+ * A task with `goalMode: true` is not completed on the worker's first
+ * successful attempt: an LLM judge checks the task's title/description (with
+ * `acceptanceCriteria` as strict numbered criteria) against the worker's
+ * output. "Continue" re-opens the task with a continuation nudge so the next
+ * tick keeps going; once `goalMaxTurns` is spent the task is BLOCKED for
+ * human review instead of spinning (Hermes' "block instead of loop" rule).
+ *
+ * The judge is fail-open (judgeGoal semantics): a broken judge yields
+ * "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';
+/**
+ * Conservative default for unattended subprocess loops (Hermes' kanban
+ * example uses 7; interactive /goal uses 20).
+ */
+export const DEFAULT_COLAB_GOAL_MAX_TURNS = 5;
+/** The goal text the judge evaluates: title + description. */
+export function goalTextForTask(task) {
+    return `${task.title}\n\n${task.description ?? ''}`.trim();
+}
+/**
+ * Continuation nudge fed to the worker on later goal-mode turns (port of
+ * Hermes' KANBAN_GOAL_CONTINUATION_TEMPLATE, adapted to the colab lifecycle:
+ * completion is decided by the loop's judge, so the worker is nudged to
+ * finish and state the outcome explicitly).
+ */
+export function buildColabGoalContinuationPrompt(task) {
+    const criteria = task.acceptanceCriteria?.length
+        ? `\nAcceptance criteria (ALL must be satisfied):\n${task.acceptanceCriteria
+            .map((text, i) => `- ${i + 1}. ${text}`)
+            .join('\n')}\n`
+        : '';
+    const lastReason = task.goalLastReason ? `\nJudge's last verdict: ${task.goalLastReason}\n` : '';
+    return ('[Continuing toward this fleet task — the judge says it is not done yet]\n' +
+        `Task: ${goalTextForTask(task)}\n` +
+        criteria +
+        lastReason +
+        '\nFinish the remaining work. When everything is done, state completion ' +
+        'explicitly with evidence (file contents, command output). If you are ' +
+        'blocked, state the blocker clearly.');
+}
+/**
+ * Default judge: a one-shot call on the same tier model the worker ran on
+ * (local tiers stay free), overridable via `goals.judgeModel`. Task
+ * `acceptanceCriteria` become strict numbered criteria for the judge.
+ */
+export function createColabGoalJudge() {
+    return async (task, result, model) => {
+        try {
+            const config = resolveGoalsConfig();
+            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,
+            });
+        }
+        catch (error) {
+            // Fail-open, like judgeGoal itself: never wedge the loop on judge setup.
+            logger.debug('colab goal judge: setup failed — continue', { error: String(error) });
+            return { verdict: 'continue', reason: `judge setup error: ${String(error)}`, parseFailed: false };
+        }
+    };
+}
+//# sourceMappingURL=colab-goal.js.map

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