@phuetz/code-buddy 1.0.0-rc.8 → 1.1.0

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/llm-provider-resolution.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared provider resolution for one-shot LLM CLI commands
+ * (`buddy research`, `buddy flow`).
+ *
+ * Historically these commands resolved ONLY through the settings
+ * provider + the `PROVIDERS` map (paid keys), so a machine running on
+ * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
+ * exit even though the rest of Code Buddy — including the autonomous
+ * daemon — runs fine there. This resolver keeps the legacy path first
+ * (backward compatible) and falls back to {@link detectProviderFromEnv}
+ * (ollama / chatgpt-oauth / env-detected providers) when either:
+ *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
+ *   - the legacy path found no key.
+ */
+export interface ResolvedCommandProvider {
+    apiKey: string;
+    baseURL?: string;
+    model?: string;
+    /** Human-readable provider name for progress output. */
+    providerLabel: string;
+}
+export declare function resolveCommandProvider(options?: {
+    explicitModel?: string;
+}): ResolvedCommandProvider | null;

package/dist/commands/llm-provider-resolution.js

@@ -0,0 +1,73 @@
+/**
+ * Shared provider resolution for one-shot LLM CLI commands
+ * (`buddy research`, `buddy flow`).
+ *
+ * Historically these commands resolved ONLY through the settings
+ * provider + the `PROVIDERS` map (paid keys), so a machine running on
+ * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
+ * exit even though the rest of Code Buddy — including the autonomous
+ * daemon — runs fine there. This resolver keeps the legacy path first
+ * (backward compatible) and falls back to {@link detectProviderFromEnv}
+ * (ollama / chatgpt-oauth / env-detected providers) when either:
+ *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
+ *   - the legacy path found no key.
+ */
+import { getSettingsManager } from '../utils/settings-manager.js';
+import { detectProviderFromEnv } from '../utils/provider-detector.js';
+import { PROVIDERS } from './provider.js';
+export function resolveCommandProvider(options = {}) {
+    const detectFirst = Boolean(process.env.CODEBUDDY_PROVIDER);
+    if (detectFirst) {
+        const detected = fromEnvDetection(options.explicitModel);
+        if (detected)
+            return detected;
+    }
+    const settingsManager = getSettingsManager();
+    const settings = settingsManager.loadUserSettings();
+    const currentProviderKey = settings.provider || 'grok';
+    const providerInfo = PROVIDERS[currentProviderKey];
+    let apiKey = process.env[providerInfo?.envVar || ''] || '';
+    if (!apiKey && currentProviderKey === 'grok')
+        apiKey = process.env.XAI_API_KEY || '';
+    if (!apiKey && currentProviderKey === 'gemini')
+        apiKey = process.env.GOOGLE_API_KEY || '';
+    if (!apiKey) {
+        apiKey =
+            process.env.GROK_API_KEY ||
+                process.env.ANTHROPIC_API_KEY ||
+                process.env.OPENAI_API_KEY ||
+                process.env.GOOGLE_API_KEY ||
+                '';
+    }
+    if (apiKey) {
+        const providerEnvBaseURL = {
+            grok: process.env.GROK_BASE_URL,
+            claude: process.env.ANTHROPIC_BASE_URL,
+            openai: process.env.OPENAI_BASE_URL,
+            gemini: process.env.GEMINI_BASE_URL,
+        };
+        return {
+            apiKey,
+            baseURL: providerEnvBaseURL[currentProviderKey] || providerInfo?.baseURL,
+            model: options.explicitModel ||
+                settingsManager.getCurrentModel() ||
+                providerInfo?.defaultModel,
+            providerLabel: providerInfo?.name || currentProviderKey,
+        };
+    }
+    // Legacy path found nothing — fall back to env detection (local
+    // Ollama, ChatGPT OAuth, …) so a $0 local machine can still run.
+    return fromEnvDetection(options.explicitModel);
+}
+function fromEnvDetection(explicitModel) {
+    const detected = detectProviderFromEnv();
+    if (!detected)
+        return null;
+    return {
+        apiKey: detected.apiKey,
+        baseURL: detected.baseURL,
+        model: explicitModel || detected.defaultModel,
+        providerLabel: detected.provider,
+    };
+}
+//# sourceMappingURL=llm-provider-resolution.js.map

package/dist/commands/research/index.js

@@ -14,8 +14,7 @@ import { WideResearchOrchestrator } from '../../agent/wide-research.js';
 import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import path from 'path';
-import { getSettingsManager } from '../../utils/settings-manager.js';
-import { PROVIDERS } from '../provider.js';
+import { resolveCommandProvider } from '../llm-provider-resolution.js';
 async function runDirectResearch(topic, apiKey, providerConfig, timeoutMs) {
     const { CodeBuddyClient } = await import('../../codebuddy/client.js');
     const client = new CodeBuddyClient(apiKey, providerConfig.model, providerConfig.baseURL);
@@ -67,31 +66,21 @@ export function createResearchCommand() {
         .option('--timeout-ms <n>', 'Overall research timeout in milliseconds (default: 300000)', '300000')
         .option('-f, --report <file>', 'Save the report to a Markdown file')
         .option('--context <text>', 'Additional context injected into each worker')
-        .action(async (topic, opts) => {
-        const settingsManager = getSettingsManager();
-        const settings = settingsManager.loadUserSettings();
-        const currentProviderKey = settings.provider || 'grok';
-        const providerInfo = PROVIDERS[currentProviderKey];
-        let apiKey = process.env[providerInfo?.envVar || ''] || '';
-        if (!apiKey && currentProviderKey === 'grok')
-            apiKey = process.env.XAI_API_KEY || '';
-        if (!apiKey && currentProviderKey === 'gemini')
-            apiKey = process.env.GOOGLE_API_KEY || '';
-        if (!apiKey)
-            apiKey = process.env.GROK_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GOOGLE_API_KEY || '';
-        if (!apiKey) {
-            console.error('❌ No API key found for the active provider. Set the appropriate environment variable.');
+        .option('-m, --model <model>', 'Override the model for this research run')
+        .option('--wide', 'Force parallel workers even in non-interactive runs (default: direct single-pass)', false)
+        .action(async (topic, opts, command) => {
+        // The root program also declares a global `-m, --model`; depending on
+        // argv order Commander can bind it there — merge so either wins.
+        const modelOverride = opts.model ?? command?.optsWithGlobals?.()?.model;
+        const resolved = resolveCommandProvider({ explicitModel: modelOverride });
+        if (!resolved) {
+            console.error('❌ No provider available — set an API key, run `buddy login`, or point CODEBUDDY_PROVIDER=ollama at a local Ollama.');
             process.exit(1);
         }
-        const providerEnvBaseURL = {
-            grok: process.env.GROK_BASE_URL,
-            claude: process.env.ANTHROPIC_BASE_URL,
-            openai: process.env.OPENAI_BASE_URL,
-            gemini: process.env.GEMINI_BASE_URL,
-        };
+        const apiKey = resolved.apiKey;
         const providerConfig = {
-            model: settingsManager.getCurrentModel() || providerInfo?.defaultModel,
-            baseURL: providerEnvBaseURL[currentProviderKey] || providerInfo?.baseURL,
+            model: resolved.model,
+            baseURL: resolved.baseURL,
         };
         const workers = Math.min(parseInt(opts.workers, 10) || 5, 20);
         const maxRoundsPerWorker = parseInt(opts.rounds, 10) || 15;
@@ -101,7 +90,7 @@ export function createResearchCommand() {
         const argvReportPath = detectReportPathFromArgv(process.argv.slice(2));
         const reportPath = opts.report || argvReportPath;
         console.log(`\n🔬 Wide Research: "${topic}"`);
-        console.log(`   Provider: ${providerInfo?.name || currentProviderKey} | Model: ${providerConfig.model}`);
+        console.log(`   Provider: ${resolved.providerLabel} | Model: ${providerConfig.model}`);
         console.log(`   Workers: ${workers}  |  Max rounds per worker: ${maxRoundsPerWorker}`);
         console.log('─'.repeat(60));
         if (!opts.report && reportPath) {
@@ -109,7 +98,9 @@ export function createResearchCommand() {
         }
         // In non-interactive runs (CI/headless), prefer a direct single-pass research call.
         // This avoids long-lived worker handles and makes output deterministic for automation.
-        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        // `--wide` opts back into the parallel-worker mode (a GUI subprocess is
+        // non-TTY but may legitimately want the full Manus-style fan-out).
+        if (!opts.wide && (!process.stdin.isTTY || !process.stdout.isTTY)) {
             console.log('ℹ️ Non-interactive mode detected, using direct research mode.');
             try {
                 const report = await runDirectResearch(topic, apiKey, providerConfig, Math.min(overallTimeoutMs, 120_000));
@@ -118,7 +109,7 @@ export function createResearchCommand() {
                     ``,
                     `Generated: ${new Date().toISOString()}`,
                     `Mode: direct`,
-                    `Provider: ${providerInfo?.name || currentProviderKey}`,
+                    `Provider: ${resolved.providerLabel}`,
                     `Model: ${providerConfig.model || 'default'}`,
                     ``,
                     `---`,

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';
+    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

@@ -21,6 +21,8 @@
  * arbitration stays "first to push wins" per the fleet protocol.
  */
 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';
 export class FleetAutonomousLoop {
     store;
     tierConfig;
@@ -34,18 +36,30 @@ 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() {
         if (!this.enabled()) {
             return { outcome: 'disabled' };
         }
+        // Saturation backpressure (fleet load balancing): when this peer is
+        // at its configured capacity (CODEBUDDY_FLEET_MAX_CONCURRENCY), it
+        // ABSTAINS from claiming. The colab queue is shared across machines,
+        // so an idle peer's daemon wins the claim instead — utilization
+        // spreads over the fleet without any new RPC. Opt-in: with no
+        // configured capacity this never triggers.
+        if (isFleetSaturated()) {
+            this.store.updatePresence({ status: 'active' });
+            return { outcome: 'saturated', detail: 'at capacity — leaving the queue to idle peers' };
+        }
         this.store.updatePresence({ status: 'active' });
         const next = this.store.nextClaimable();
         if (!next) {
@@ -66,13 +80,25 @@ export class FleetAutonomousLoop {
         const failures = this.failures.get(task.id) ?? 0;
         const model = chooseAutonomousModel(this.tierConfig, { priority: task.priority, ...(failures > 0 ? { failures } : {}) }, this.policy);
         let result;
+        const doneLoad = beginFleetWork('autonomy.task');
         try {
             result = await this.executor(task, model);
         }
         catch (err) {
             result = { ok: false, summary: 'executor threw', error: err instanceof Error ? err.message : String(err) };
         }
+        finally {
+            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,
@@ -103,5 +129,54 @@ 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 = task.goalMaxTurns ?? DEFAULT_COLAB_GOAL_MAX_TURNS;
+        const turnsUsed = (task.goalTurnsUsed ?? 0) + 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.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