@phuetz/code-buddy 1.0.0 → 1.1.0

package/dist/commands/goal-cli.js

@@ -0,0 +1,97 @@
+/**
+ * buddy goal — headless Ralph loop.
+ *
+ * Runs the full agentic loop toward a standing goal: each turn the agent
+ * works with tools, then the goal judge decides done/continue. Continuation
+ * prompts are fed back in-process until the goal is achieved, the turn
+ * budget is exhausted, or the judge auto-pauses.
+ *
+ * Usage:
+ *   buddy goal "Fix every failing test in tests/auth/"
+ *   buddy goal "Ship the feature" --max-turns 10 --judge-model qwen3:8b
+ *
+ * Exit codes: 0 = goal done, 1 = paused (budget/judge) or error.
+ */
+import { Command } from 'commander';
+import { maybeContinueGoalAfterTurn } from '../goals/goal-loop.js';
+import { getGoalManager } from '../goals/goal-manager.js';
+import { resolveCommandProvider } from './llm-provider-resolution.js';
+/**
+ * Drive the goal loop headlessly on an in-process agent. Sets the goal,
+ * runs the first turn with the goal text (mirroring the interactive
+ * `/goal <text>` kick-off), then follows judge verdicts until the loop
+ * stops continuing.
+ */
+export async function runGoalLoop(agent, goalText, options = {}) {
+    const manager = getGoalManager();
+    const state = manager.set(goalText, options.maxTurns ? { maxTurns: options.maxTurns } : {});
+    const emit = options.onMessage ?? (() => { });
+    emit(`⊙ Goal set (${state.maxTurns}-turn budget): ${state.goal}`);
+    let prompt = state.goal;
+    // Hard backstop on top of the manager's own budget/auto-pause guards.
+    const maxIterations = state.maxTurns + 1;
+    for (let i = 0; i < maxIterations; i++) {
+        const entries = await agent.processUserMessage(prompt);
+        const lastResponse = entries
+            .filter(entry => entry.type === 'assistant' && entry.content)
+            .map(entry => entry.content)
+            .join('\n');
+        const outcome = await maybeContinueGoalAfterTurn({
+            client: agent.getClient(),
+            lastResponse,
+            interrupted: false,
+        });
+        if (outcome?.message)
+            emit(outcome.message);
+        if (!outcome?.continuationPrompt)
+            break;
+        prompt = outcome.continuationPrompt;
+    }
+    const final = manager.state;
+    return {
+        status: final?.status ?? 'unknown',
+        turnsUsed: final?.turnsUsed ?? 0,
+        ...(final?.lastReason ? { lastReason: final.lastReason } : {}),
+    };
+}
+export function createGoalCommand() {
+    const cmd = new Command('goal')
+        .description('Run the agent toward a standing goal until a judge model confirms it is done (Ralph loop)')
+        .argument('<goal>', 'The goal to pursue')
+        .option('--max-turns <n>', 'Turn budget (default 20, or goals.maxTurns from settings)')
+        .option('--judge-model <model>', 'Model for the goal judge (default: session model)')
+        .option('-m, --model <model>', 'Override the agent model for this run')
+        .option('--max-tool-rounds <n>', 'Max tool rounds per turn', '50')
+        .action(async (goal, options, command) => {
+        const modelOverride = options.model ?? command?.optsWithGlobals?.()?.model;
+        const resolved = resolveCommandProvider({ explicitModel: modelOverride });
+        if (!resolved) {
+            console.error('Error: No provider available — set an API key, run `buddy onboard`, or point CODEBUDDY_PROVIDER=ollama at a local Ollama.');
+            process.exit(1);
+        }
+        if (options.judgeModel) {
+            process.env.CODEBUDDY_GOAL_JUDGE_MODEL = options.judgeModel;
+        }
+        process.env.CODEBUDDY_DISABLE_MCP = process.env.CODEBUDDY_DISABLE_MCP ?? 'true';
+        process.env.CODEBUDDY_HEADLESS = 'true';
+        try {
+            const { CodeBuddyAgent } = await import('../agent/codebuddy-agent.js');
+            const { ConfirmationService } = await import('../utils/confirmation-service.js');
+            ConfirmationService.getInstance().setSessionFlag('allOperations', true);
+            const agent = new CodeBuddyAgent(resolved.apiKey, resolved.baseURL, resolved.model, parseInt(options.maxToolRounds, 10));
+            await agent.systemPromptReady;
+            const result = await runGoalLoop(agent, goal, {
+                ...(options.maxTurns ? { maxTurns: parseInt(options.maxTurns, 10) } : {}),
+                onMessage: text => console.log(`\n${text}`),
+            });
+            agent.dispose?.();
+            process.exit(result.status === 'done' ? 0 : 1);
+        }
+        catch (err) {
+            console.error('Goal error:', err instanceof Error ? err.message : err);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=goal-cli.js.map

package/dist/commands/handlers/goal-handler.d.ts

@@ -0,0 +1,27 @@
+import { CommandHandlerResult } from './branch-handlers.js';
+/**
+ * /goal — standing goal with judge + auto-continue loop (the Ralph loop,
+ * ported from Hermes Agent).
+ *
+ * Forms:
+ *   /goal <text>     set a new goal (replaces any old one) and start turn 1
+ *   /goal | status   show current state
+ *   /goal pause      halt auto-continuation, keep the goal
+ *   /goal resume     restart the loop (resets the turn budget)
+ *   /goal clear      discard the goal (aliases: stop, done)
+ */
+export declare function handleGoal(args: string[]): Promise<CommandHandlerResult>;
+/**
+ * /subgoal — extra acceptance criteria added mid-loop.
+ *
+ * Forms:
+ *   /subgoal                show current subgoals
+ *   /subgoal <text>         append a criterion
+ *   /subgoal remove <n>     drop subgoal n (1-based)
+ *   /subgoal clear          wipe all subgoals
+ *
+ * Subgoals get appended to both the judge prompt (verdict must consider
+ * them) and the continuation prompt (agent sees them) on the next turn
+ * boundary — no special kick needed.
+ */
+export declare function handleSubgoal(args: string[]): Promise<CommandHandlerResult>;

package/dist/commands/handlers/goal-handler.js

@@ -0,0 +1,128 @@
+import { getGoalManager } from '../../goals/goal-manager.js';
+/**
+ * /goal — standing goal with judge + auto-continue loop (the Ralph loop,
+ * ported from Hermes Agent).
+ *
+ * Forms:
+ *   /goal <text>     set a new goal (replaces any old one) and start turn 1
+ *   /goal | status   show current state
+ *   /goal pause      halt auto-continuation, keep the goal
+ *   /goal resume     restart the loop (resets the turn budget)
+ *   /goal clear      discard the goal (aliases: stop, done)
+ */
+export async function handleGoal(args) {
+    const arg = args.join(' ').trim();
+    const lower = arg.toLowerCase();
+    const mgr = getGoalManager();
+    if (!arg || lower === 'status') {
+        return textResult(mgr.statusLine());
+    }
+    if (lower === 'pause') {
+        const state = mgr.pause('user-paused');
+        return textResult(state ? `⏸ Goal paused: ${state.goal}` : 'No goal set.');
+    }
+    if (lower === 'resume') {
+        const state = mgr.resume();
+        if (!state) {
+            return textResult('No goal to resume.');
+        }
+        return textResult(`▶ Goal resumed: ${state.goal}\n` +
+            'Send any message to kick the loop off (e.g. "continue").');
+    }
+    if (['clear', 'stop', 'done'].includes(lower)) {
+        const had = mgr.hasGoal();
+        mgr.clear();
+        return textResult(had ? '✓ Goal cleared.' : 'No active goal.');
+    }
+    // Otherwise treat the arg as the goal text.
+    let state;
+    try {
+        state = mgr.set(arg);
+    }
+    catch (error) {
+        return textResult(`Invalid goal: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return {
+        handled: true,
+        entry: {
+            type: 'assistant',
+            content: `⊙ Goal set (${state.maxTurns}-turn budget): ${state.goal}\n` +
+                'After each turn, a judge model checks if the goal is done. Code Buddy ' +
+                'keeps working until it is, you pause/clear it, or the budget is ' +
+                'exhausted. Use /goal status, /goal pause, /goal resume, /goal clear. ' +
+                'Tip: for unattended runs, enable auto-approval (/yolo or auto-edit) so ' +
+                'the loop is not blocked on confirmations.',
+            timestamp: new Date(),
+        },
+        // Kick the loop off immediately — the dispatcher feeds the goal text as
+        // the first turn, then the after-turn hook drives the continuation loop.
+        passToAI: true,
+        prompt: state.goal,
+    };
+}
+/**
+ * /subgoal — extra acceptance criteria added mid-loop.
+ *
+ * Forms:
+ *   /subgoal                show current subgoals
+ *   /subgoal <text>         append a criterion
+ *   /subgoal remove <n>     drop subgoal n (1-based)
+ *   /subgoal clear          wipe all subgoals
+ *
+ * Subgoals get appended to both the judge prompt (verdict must consider
+ * them) and the continuation prompt (agent sees them) on the next turn
+ * boundary — no special kick needed.
+ */
+export async function handleSubgoal(args) {
+    const arg = args.join(' ').trim();
+    const mgr = getGoalManager();
+    if (!mgr.hasGoal()) {
+        return textResult('No active goal. Set one with /goal <text>.');
+    }
+    if (!arg) {
+        return textResult(`${mgr.statusLine()}\n${mgr.renderSubgoals()}`);
+    }
+    const [verb, ...restTokens] = arg.split(/\s+/);
+    const rest = restTokens.join(' ').trim();
+    if (verb?.toLowerCase() === 'remove') {
+        if (!rest) {
+            return textResult('Usage: /subgoal remove <n>');
+        }
+        const idx = Number(rest.split(/\s+/)[0]);
+        if (!Number.isInteger(idx)) {
+            return textResult('/subgoal remove: <n> must be an integer (1-based index).');
+        }
+        try {
+            const removed = mgr.removeSubgoal(idx);
+            return textResult(`✓ Removed subgoal ${idx}: ${removed}`);
+        }
+        catch (error) {
+            return textResult(`/subgoal remove: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (verb?.toLowerCase() === 'clear') {
+        try {
+            const prev = mgr.clearSubgoals();
+            return textResult(prev ? `✓ Cleared ${prev} subgoal${prev !== 1 ? 's' : ''}.` : 'No subgoals to clear.');
+        }
+        catch (error) {
+            return textResult(`/subgoal clear: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Otherwise — append the whole arg as a new subgoal.
+    try {
+        const text = mgr.addSubgoal(arg);
+        const idx = mgr.state?.subgoals.length ?? 0;
+        return textResult(`✓ Added subgoal ${idx}: ${text}`);
+    }
+    catch (error) {
+        return textResult(`/subgoal: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function textResult(content) {
+    return {
+        handled: true,
+        entry: { type: 'assistant', content, timestamp: new Date() },
+    };
+}
+//# sourceMappingURL=goal-handler.js.map

package/dist/commands/handlers/index.d.ts

@@ -36,6 +36,7 @@ export { handleFastMode, isFastModeEnabled, getFastModeModel, getFastModeService
 export { handleBackup, } from './backup-handlers.js';
 export { handleBtw, setBtwClient, } from './btw-handler.js';
 export { handleHeartbeat } from './heartbeat-handler.js';
+export { handleGoal, handleSubgoal } from './goal-handler.js';
 export { handleDailyReset } from './daily-reset-handler.js';
 export { handleShare } from './team-session-handler.js';
 export { handleAgents } from './agents-handler.js';

package/dist/commands/handlers/index.js

@@ -74,6 +74,8 @@ export { handleBackup, } from './backup-handlers.js';
 export { handleBtw, setBtwClient, } from './btw-handler.js';
 // Heartbeat handler (fleet AUTONOMOUS-FLEET-PROTOCOL v0.1)
 export { handleHeartbeat } from './heartbeat-handler.js';
+// Goal handler (Hermes Agent parity — Ralph loop)
+export { handleGoal, handleSubgoal } from './goal-handler.js';
 // Daily reset handler (audit OpenClaw heritage activation)
 export { handleDailyReset } from './daily-reset-handler.js';
 // Team session handler — slash /share (audit OpenClaw heritage activation, TeamSessionManager wake)

package/dist/commands/slash/builtin-commands.js

@@ -808,6 +808,26 @@ const personaCommands = [
 // Autonomy & Permissions Commands
 // ============================================================================
 const autonomyCommands = [
+    {
+        name: 'goal',
+        description: 'Standing goal with judge + auto-continue loop (Ralph loop): /goal <text> | status | pause | resume | clear',
+        prompt: '__GOAL__',
+        filePath: '',
+        isBuiltin: true,
+        arguments: [
+            { name: 'action', description: '<text> to set a goal, or status, pause, resume, clear', required: false }
+        ]
+    },
+    {
+        name: 'subgoal',
+        description: 'Add acceptance criteria to the active goal: /subgoal <text> | remove <n> | clear',
+        prompt: '__SUBGOAL__',
+        filePath: '',
+        isBuiltin: true,
+        arguments: [
+            { name: 'action', description: '<text> to add a criterion, remove <n>, clear, or empty to list', required: false }
+        ]
+    },
     {
         name: 'yolo',
         description: 'Toggle YOLO mode (full auto-execution with guardrails)',

package/dist/config/env-schema.js

@@ -69,6 +69,20 @@ export const ENV_SCHEMA = [
         category: 'core',
         min: 1000,
     },
+    {
+        name: 'CODEBUDDY_GOAL_MAX_TURNS',
+        type: 'number',
+        description: 'Turn budget for /goal auto-continue loops (default 20)',
+        category: 'core',
+        min: 1,
+        max: 1000,
+    },
+    {
+        name: 'CODEBUDDY_GOAL_JUDGE_MODEL',
+        type: 'string',
+        description: 'Model used by the /goal judge (default: current session model)',
+        category: 'core',
+    },
     {
         name: 'GROK_FORCE_TOOLS',
         type: 'boolean',

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/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,
@@ -921,6 +928,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.js

@@ -18,6 +18,7 @@ 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;
@@ -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;
 }