@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/commands/cli/native-engine-commands.js

@@ -9,6 +9,16 @@ import { buildHeartbeatStatusReport } from '../../daemon/status-reports.js';
 // Heartbeat commands
 // ============================================================================
 export { buildHeartbeatStatusReport };
+function parsePositiveIntegerCliOption(value, flagName) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    const n = Number(trimmed);
+    if (!/^[1-9]\d*$/.test(trimmed) || !Number.isSafeInteger(n)) {
+        throw new Error(`${flagName} must be a positive integer`);
+    }
+    return n;
+}
 export function registerHeartbeatCommands(program) {
     const heartbeat = program
         .command('heartbeat')
@@ -745,7 +755,7 @@ export function registerFleetAutonomyCommands(program) {
         .action(async (opts) => {
         const { createDefaultAutonomousLoop, FleetAutonomousDaemon, watchFleetTasks } = await import('../../daemon/autonomous-daemon.js');
         const path = await import('path');
-        const loop = createDefaultAutonomousLoop({
+        const loop = await createDefaultAutonomousLoop({
             ...(opts.dir ? { dir: opts.dir } : {}),
             ...(opts.outputDir ? { outputDir: opts.outputDir } : {}),
         });
@@ -780,6 +790,86 @@ export function registerFleetAutonomyCommands(program) {
             console.log(`\nDone: ${summary.ticks} tick(s), ${JSON.stringify(summary.outcomes)} (${summary.stoppedReason}).`);
         }
     });
+    fleet
+        .command('bench')
+        .description('Benchmark live Tailnet Ollama peers and rank the network model tier')
+        .option('--peer <pattern>', 'only benchmark peers whose hostname or IP contains the pattern')
+        .option('--models <csv>', 'only benchmark models whose name contains one of the comma-separated patterns')
+        .option('--prompt-set <name>', 'prompt set: balanced, coding, or latency', 'coding')
+        .option('--runs <n>', 'repeat the prompt set N times per candidate', '1')
+        .option('--timeout <ms>', 'request timeout per prompt', '60000')
+        .option('--json', 'output JSON')
+        .option('--no-write-cache', 'do not persist the score cache used by the router')
+        .action(async (opts) => {
+        const { TailscaleManager } = await import('../../integrations/tailscale.js');
+        const { BENCHMARK_PROMPT_SETS, benchmarkCandidates, writeBenchmarkIndex, defaultBenchmarkIndexPath, } = await import('../../agent/model-benchmark.js');
+        const peers = await TailscaleManager.getInstance().discoverOllamaPeers();
+        const filteredPeers = opts.peer
+            ? peers.filter((peer) => peer.hostname.toLowerCase().includes(opts.peer.toLowerCase())
+                || peer.ip.includes(opts.peer.trim()))
+            : peers;
+        const modelFilters = opts.models
+            ? opts.models.split(',').map((part) => part.trim()).filter(Boolean)
+            : [];
+        const candidates = filteredPeers.flatMap((peer) => peer.models
+            .filter((model) => modelFilters.length === 0
+            ? true
+            : modelFilters.some((filter) => model.toLowerCase().includes(filter.toLowerCase())))
+            .map((model) => ({
+            model,
+            baseUrl: peer.baseURL,
+            label: peer.hostname,
+        })));
+        if (candidates.length === 0) {
+            const message = opts.peer
+                ? `No Tailnet Ollama peers matched "${opts.peer}".`
+                : 'No Tailnet Ollama peers were discovered.';
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+                return;
+            }
+            console.log(message);
+            return;
+        }
+        const suite = BENCHMARK_PROMPT_SETS[opts.promptSet] ? opts.promptSet : 'coding';
+        const reports = await benchmarkCandidates(candidates, {
+            promptSet: suite,
+            runs: Math.max(1, parseInt(opts.runs, 10) || 1),
+            timeoutMs: Math.max(5_000, parseInt(opts.timeout, 10) || 60_000),
+        });
+        const ranked = [...reports].sort((a, b) => b.summary.score - a.summary.score);
+        let indexPath;
+        if (opts.writeCache !== false) {
+            indexPath = defaultBenchmarkIndexPath();
+            await writeBenchmarkIndex(ranked, suite, indexPath);
+        }
+        const best = ranked[0];
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                suite,
+                indexPath,
+                best,
+                reports: ranked,
+            }, null, 2));
+            return;
+        }
+        console.log(`\nTailnet Ollama benchmark (${suite})`);
+        if (indexPath)
+            console.log(`  Cache: ${indexPath}`);
+        console.log(`  Candidates: ${ranked.length}`);
+        if (best) {
+            console.log(`  Best: ${best.candidate.label ?? best.candidate.model} / ${best.candidate.model}`);
+            console.log(`    Score: ${best.summary.score.toFixed(1)}  compliance ${(best.summary.complianceRate * 100).toFixed(0)}%  ttft ${Math.round(best.summary.avgTtftMs)}ms  total ${Math.round(best.summary.avgTotalMs)}ms`);
+        }
+        console.log('');
+        ranked.forEach((report, index) => {
+            console.log(`${String(index + 1).padStart(2, ' ')}. ${report.candidate.label ?? report.candidate.model} / ${report.candidate.model}`);
+            console.log(`    ${report.candidate.baseUrl}`);
+            console.log(`    score=${report.summary.score.toFixed(1)} compliance=${(report.summary.complianceRate * 100).toFixed(0)}% ttft=${Math.round(report.summary.avgTtftMs)}ms total=${Math.round(report.summary.avgTotalMs)}ms`);
+        });
+        console.log('');
+    });
     fleet
         .command('status')
         .description('Show the fleet task queue + presence')
@@ -817,9 +907,20 @@ export function registerFleetAutonomyCommands(program) {
         .option('--priority <p>', 'critical | high | medium | low', 'medium')
         .option('--depends-on <ids>', 'comma-separated task ids this task depends on')
         .option('--description <text>', 'task description')
+        .option('--goal-mode', 'judge-gated loop: the worker keeps going until an LLM judge confirms the task is done, then blocks for human review when the budget is spent')
+        .option('--goal-max-turns <n>', 'goal-mode turn budget (default 5)')
         .option('--dir <path>', 'colab dir')
         .option('--json', 'output JSON')
         .action(async (title, opts) => {
+        let goalMaxTurns;
+        try {
+            goalMaxTurns = parsePositiveIntegerCliOption(opts.goalMaxTurns, '--goal-max-turns');
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+            return;
+        }
         const { FleetColabStore } = await import('../../fleet/colab-store.js');
         const store = new FleetColabStore({ ...(opts.dir ? { dir: opts.dir } : {}) });
         const priority = ['critical', 'high', 'medium', 'low'].find((p) => p === opts.priority) ?? 'medium';
@@ -828,12 +929,15 @@ export function registerFleetAutonomyCommands(program) {
             priority,
             ...(opts.description ? { description: opts.description } : {}),
             ...(opts.dependsOn ? { dependsOn: opts.dependsOn.split(',').map((s) => s.trim()).filter(Boolean) } : {}),
+            ...(opts.goalMode ? { goalMode: true } : {}),
+            ...(goalMaxTurns !== undefined ? { goalMaxTurns } : {}),
         });
         if (opts.json) {
             console.log(JSON.stringify({ task }, null, 2));
             return;
         }
-        console.log(`Added task ${task.id} [${task.priority}]${task.dependsOn ? ` depends on ${task.dependsOn.join(', ')}` : ''}`);
+        const goalNote = task.goalMode ? ` goal-mode(${task.goalMaxTurns ?? 5} turns)` : '';
+        console.log(`Added task ${task.id} [${task.priority}]${goalNote}${task.dependsOn ? ` depends on ${task.dependsOn.join(', ')}` : ''}`);
     });
     fleet
         .command('swarm <goal>')
@@ -1124,7 +1228,7 @@ export function registerCompanionCommands(program) {
         .option('--no-set-model', 'Do not set the project model to the ChatGPT companion default')
         .option('--language <lang>', 'Voice language', 'fr')
         .option('--stt-provider <provider>', 'Voice input provider (system, whisper-local, whisper-api)')
-        .option('--tts-provider <provider>', 'TTS provider (edge-tts, espeak, say, piper, audioreader, kokoro)')
+        .option('--tts-provider <provider>', 'TTS provider (edge-tts, espeak, say, piper, audioreader)')
         .option('--tts-voice <voice>', 'TTS voice name')
         .option('--model <model>', 'ChatGPT model to use when OAuth credentials are present')
         .action(async (opts) => {

package/dist/commands/cli/utility-commands.js

@@ -4,6 +4,7 @@
  * Extracted from index.ts for modularity.
  */
 import { resolve } from 'path';
+import { buildOllamaUpdatePlan, fetchOllamaStatus, runOllamaUpdatePlan } from '../ollama.js';
 function resolveCommandDirectory(program) {
     const directory = program.opts().directory;
     return resolve(process.cwd(), directory || process.cwd());
@@ -93,6 +94,50 @@ export function registerUtilityCommands(program) {
         const { runOnboarding } = await import('../../wizard/onboarding.js');
         await runOnboarding();
     });
+    const ollamaCommand = program
+        .command('ollama')
+        .description('Inspect or update the local Ollama runtime');
+    ollamaCommand
+        .command('status')
+        .description('Show local Ollama version and models')
+        .option('--url <url>', 'Ollama base URL', process.env.OLLAMA_HOST ?? 'http://localhost:11434')
+        .option('--json', 'Output JSON')
+        .action(async (options) => {
+        const status = await fetchOllamaStatus(options.url);
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        console.log('\nOllama status\n');
+        console.log(`  Base URL: ${status.baseUrl}`);
+        console.log(`  Reachable: ${status.reachable ? 'YES' : 'NO'}`);
+        console.log(`  Version: ${status.version ?? '(unknown)'}`);
+        console.log(`  Models: ${status.models.length > 0 ? status.models.join(', ') : '(none)'}`);
+        if (status.error) {
+            console.log(`  Error: ${status.error}`);
+        }
+        console.log('');
+    });
+    ollamaCommand
+        .command('update')
+        .description('Run the official Ollama Windows update script')
+        .option('--script-url <url>', 'Official installer/update script URL', 'https://ollama.com/install.ps1')
+        .option('--repo-root <dir>', 'Repository root', resolveCommandDirectory(program))
+        .action(async (options) => {
+        const plan = buildOllamaUpdatePlan({
+            repoRoot: options.repoRoot,
+            scriptUrl: options.scriptUrl,
+        });
+        if (!plan.supported) {
+            console.error(plan.message);
+            console.error(`Use the update script directly on Windows: ${plan.scriptPath}`);
+            process.exit(1);
+            return;
+        }
+        console.log(`Running Ollama updater: ${plan.scriptPath}`);
+        await runOllamaUpdatePlan(plan);
+        console.log('Ollama update completed.');
+    });
     // Webhook command
     const webhookCommand = program
         .command('webhook')

package/dist/commands/enhanced-command-handler.js

@@ -62,6 +62,8 @@ handleFastMode,
 handleBtw, setBtwClient, 
 // Heartbeat handler (V4.x — wire user-facing activation of HeartbeatEngine)
 handleHeartbeat, 
+// Goal handler (Hermes Agent parity — Ralph loop)
+handleGoal, handleSubgoal, 
 // Daily reset handler (audit OpenClaw heritage activation)
 handleDailyReset, 
 // Team session handler — slash /share (audit OpenClaw heritage activation, TeamSessionManager wake)
@@ -337,6 +339,9 @@ export class EnhancedCommandHandler {
         ['__BTW__', (args) => handleBtw(args)],
         // Heartbeat engine activation (fleet AUTONOMOUS-FLEET-PROTOCOL v0.1)
         ['__HEARTBEAT__', (args) => handleHeartbeat(args)],
+        // Standing goal — judge + auto-continue loop (Hermes Agent parity)
+        ['__GOAL__', (args) => handleGoal(args, { client: this.codebuddyClient })],
+        ['__SUBGOAL__', (args) => handleSubgoal(args)],
         // Daily reset scheduler (audit OpenClaw heritage activation)
         ['__DAILY_RESET__', (args) => handleDailyReset(args)],
         // Team session manager — slash /share (audit OpenClaw heritage, TeamSessionManager wake)

package/dist/commands/goal-cli.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 type { ChatEntry } from '../agent/codebuddy-agent.js';
+import type { CodeBuddyClient } from '../codebuddy/client.js';
+import { type GoalJudgeProviderInfo } from '../goals/goal-judge-client.js';
+import { GoalStatus } from '../goals/goal-state.js';
+/** The slice of CodeBuddyAgent the loop needs — injectable for tests. */
+export interface GoalLoopAgent {
+    processUserMessage(input: string): Promise<ChatEntry[]>;
+    getClient(): CodeBuddyClient;
+}
+export interface GoalCommandRuntimeAgent extends GoalLoopAgent {
+    systemPromptReady: Promise<unknown>;
+    setSystemPrompt?: (prompt: string) => void;
+    dispose?: () => void | Promise<void>;
+}
+export interface GoalLoopRunOptions {
+    maxTurns?: number;
+    /** Optional standalone judge client. Defaults to the agent client. */
+    judgeClient?: CodeBuddyClient;
+    /** Progress sink (status lines ⊙/↻/✓/⏸). Defaults to silent. */
+    onMessage?: (text: string) => void;
+}
+export interface GoalLoopRunResult {
+    status: GoalStatus | 'unknown';
+    turnsUsed: number;
+    lastReason?: string;
+}
+export interface GoalCommandRuntimeOptions {
+    maxTurns?: number;
+    judgeModel?: string;
+    provider: GoalJudgeProviderInfo;
+    workingDirectory?: string;
+    onMessage?: (text: string) => void;
+    createJudgeClient?: typeof createStandaloneJudgeClient;
+    runLoop?: typeof runGoalLoop;
+}
+export declare const LOCAL_GOAL_ACTOR_SYSTEM_PROMPT: string;
+export declare function buildLocalGoalActorSystemPrompt(workingDirectory?: string): string;
+export declare function shouldUseLocalGoalActorPrompt(provider: GoalJudgeProviderInfo): boolean;
+export declare function resolveLocalGoalActorSystemPrompt(provider: GoalJudgeProviderInfo, workingDirectory?: string): string | undefined;
+/**
+ * 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 declare function runGoalLoop(agent: GoalLoopAgent, goalText: string, options?: GoalLoopRunOptions): Promise<GoalLoopRunResult>;
+declare function createStandaloneJudgeClient(judgeModel: string | undefined, agentProvider: GoalJudgeProviderInfo, currentClient: CodeBuddyClient): Promise<CodeBuddyClient | undefined>;
+export declare function runGoalCommandWithAgent(agent: GoalCommandRuntimeAgent, goal: string, options: GoalCommandRuntimeOptions): Promise<GoalLoopRunResult>;
+export declare function resolveGoalCliJudgeModel(explicitJudgeModel: string | undefined): string | undefined;
+export declare function resolveGoalCliMaxToolRounds(commandValue: number | undefined, command?: Command): number;
+export declare function resolveGoalCliWorkingDirectory(command?: Command): string | undefined;
+export declare function applyGoalCliWorkingDirectory(command?: Command): string;
+export declare function parsePositiveIntegerOption(value: string, optionName: string): number;
+export declare function validateGoalCommandNumericOptions(argv: readonly string[]): void;
+export declare function createGoalCommand(): Command;
+export {};

package/dist/commands/goal-cli.js

@@ -0,0 +1,280 @@
+/**
+ * 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, InvalidArgumentError } from 'commander';
+import path from 'path';
+import { resolveGoalJudgeClient } from '../goals/goal-judge-client.js';
+import { maybeContinueGoalAfterTurn } from '../goals/goal-loop.js';
+import { getGoalManager, resolveGoalsConfig } from '../goals/goal-manager.js';
+import { resolveCommandProvider } from './llm-provider-resolution.js';
+const TOOL_RESULT_SNIPPET_CHARS = 1600;
+export const LOCAL_GOAL_ACTOR_SYSTEM_PROMPT = 'You are Code Buddy running in headless goal mode on a local model. ' +
+    'Work only toward the user standing goal. Use available tools when they are necessary, ' +
+    'then report concrete progress or the final result. For simple answer-only goals, ' +
+    'output exactly the requested answer and no extra text. Do not greet the user, add markdown, ' +
+    'or explain unless the goal asks for it.';
+export function buildLocalGoalActorSystemPrompt(workingDirectory = process.cwd()) {
+    return `${LOCAL_GOAL_ACTOR_SYSTEM_PROMPT}
+
+Workspace:
+- Current project directory: ${workingDirectory}
+- Use paths relative to the current project directory whenever possible.
+- Do not invent container paths such as /workspace or root paths such as /src unless a tool result proves they exist.`;
+}
+export function shouldUseLocalGoalActorPrompt(provider) {
+    const label = provider.providerLabel?.toLowerCase() ?? '';
+    const baseURL = provider.baseURL?.toLowerCase() ?? '';
+    return provider.apiKey === 'ollama' || label.includes('ollama') || baseURL.includes(':11434');
+}
+export function resolveLocalGoalActorSystemPrompt(provider, workingDirectory = process.cwd()) {
+    return shouldUseLocalGoalActorPrompt(provider)
+        ? buildLocalGoalActorSystemPrompt(workingDirectory)
+        : undefined;
+}
+function truncateGoalTurnPart(text) {
+    if (text.length <= TOOL_RESULT_SNIPPET_CHARS)
+        return text;
+    return `${text.slice(0, TOOL_RESULT_SNIPPET_CHARS)}... [truncated]`;
+}
+function buildGoalTurnSummary(entries) {
+    const parts = [];
+    let hasToolResult = false;
+    for (const entry of entries) {
+        if (entry.type === 'assistant' && entry.content.trim()) {
+            parts.push(entry.content.trim());
+            continue;
+        }
+        if (entry.type !== 'tool_result')
+            continue;
+        hasToolResult = true;
+        const toolOutput = (entry.toolResult?.success ? entry.toolResult.output : entry.toolResult?.error) ??
+            entry.content;
+        const trimmedOutput = String(toolOutput ?? '').trim();
+        if (!trimmedOutput)
+            continue;
+        const toolName = entry.toolCall?.function?.name ?? 'tool';
+        const status = entry.toolResult ? (entry.toolResult.success ? 'success' : 'error') : 'result';
+        parts.push(`[tool:${toolName} ${status}]\n${truncateGoalTurnPart(trimmedOutput)}`);
+    }
+    const summary = parts.join('\n\n');
+    if (summary && !hasToolResult) {
+        return `[tool evidence: none]\n\n${summary}`;
+    }
+    return summary;
+}
+function buildGoalRunSummary(turnSummaries) {
+    return turnSummaries
+        .map((summary, index) => `[Goal turn ${index + 1}]\n${summary}`)
+        .join('\n\n');
+}
+/**
+ * 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 !== undefined ? { maxTurns: options.maxTurns } : {});
+    const emit = options.onMessage ?? (() => { });
+    const judgeClient = options.judgeClient ?? agent.getClient();
+    emit(`⊙ Goal set (${state.maxTurns}-turn budget): ${state.goal}`);
+    let prompt = state.goal;
+    const turnSummaries = [];
+    // 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 = buildGoalTurnSummary(entries);
+        if (lastResponse.trim()) {
+            turnSummaries.push(lastResponse);
+        }
+        const outcome = await maybeContinueGoalAfterTurn({
+            client: judgeClient,
+            lastResponse: lastResponse.trim() ? buildGoalRunSummary(turnSummaries) : lastResponse,
+            interrupted: false,
+        });
+        if (outcome?.message)
+            emit(outcome.message);
+        if (!outcome && !lastResponse.trim() && manager.isActive()) {
+            manager.pause('empty response (nothing to evaluate)');
+            emit('⏸ Goal paused — the agent produced no judgeable response.');
+            break;
+        }
+        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 } : {}),
+    };
+}
+async function createStandaloneJudgeClient(judgeModel, agentProvider, currentClient) {
+    const resolved = await resolveGoalJudgeClient(currentClient, judgeModel, agentProvider);
+    return resolved === currentClient ? undefined : resolved;
+}
+export async function runGoalCommandWithAgent(agent, goal, options) {
+    try {
+        const createJudgeClient = options.createJudgeClient ?? createStandaloneJudgeClient;
+        const runLoop = options.runLoop ?? runGoalLoop;
+        const judgeClient = await createJudgeClient(options.judgeModel, options.provider, agent.getClient());
+        await agent.systemPromptReady;
+        if (shouldUseLocalGoalActorPrompt(options.provider)) {
+            agent.setSystemPrompt?.(buildLocalGoalActorSystemPrompt(options.workingDirectory));
+        }
+        return await runLoop(agent, goal, {
+            ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
+            ...(judgeClient ? { judgeClient } : {}),
+            ...(options.onMessage ? { onMessage: options.onMessage } : {}),
+        });
+    }
+    finally {
+        await Promise.resolve(agent.dispose?.());
+    }
+}
+export function resolveGoalCliJudgeModel(explicitJudgeModel) {
+    const explicit = explicitJudgeModel?.trim();
+    if (explicit)
+        return explicit;
+    const configured = resolveGoalsConfig().judgeModel.trim();
+    return configured || undefined;
+}
+export function resolveGoalCliMaxToolRounds(commandValue, command) {
+    const commandSource = command?.getOptionValueSource?.('maxToolRounds');
+    if (commandSource && commandSource !== 'default') {
+        return commandValue ?? 50;
+    }
+    const parentSource = command?.parent?.getOptionValueSource?.('maxToolRounds');
+    const parentValue = command?.optsWithGlobals?.()?.maxToolRounds;
+    if (parentSource && parentSource !== 'default' && parentValue !== undefined) {
+        return parsePositiveIntegerOption(String(parentValue), '--max-tool-rounds');
+    }
+    return commandValue ?? 50;
+}
+export function resolveGoalCliWorkingDirectory(command) {
+    const value = command?.optsWithGlobals?.()?.directory;
+    if (typeof value !== 'string')
+        return undefined;
+    const directory = value.trim();
+    if (!directory)
+        return undefined;
+    return path.resolve(process.cwd(), directory);
+}
+export function applyGoalCliWorkingDirectory(command) {
+    const directory = resolveGoalCliWorkingDirectory(command);
+    if (directory) {
+        process.chdir(directory);
+    }
+    return process.cwd();
+}
+async function loadGoalCliEnv(directory) {
+    const dotenv = await import('dotenv');
+    dotenv.config({ path: path.join(directory, '.env') });
+}
+async function prepareGoalCliWorkspace(command) {
+    const launchDirectory = process.cwd();
+    await loadGoalCliEnv(launchDirectory);
+    const cwd = applyGoalCliWorkingDirectory(command);
+    if (cwd !== launchDirectory) {
+        await loadGoalCliEnv(cwd);
+    }
+    const opts = command?.optsWithGlobals?.();
+    const { initializeWorkspaceIsolation } = await import('../workspace/workspace-isolation.js');
+    initializeWorkspaceIsolation({
+        allowOutside: opts?.allowOutside,
+        directory: cwd,
+        additionalPaths: opts?.addDir,
+    });
+    return cwd;
+}
+export function parsePositiveIntegerOption(value, optionName) {
+    const trimmed = value.trim();
+    const n = Number(trimmed);
+    if (!/^[1-9]\d*$/.test(trimmed) || !Number.isSafeInteger(n)) {
+        throw new InvalidArgumentError(`${optionName} must be a positive integer`);
+    }
+    return n;
+}
+export function validateGoalCommandNumericOptions(argv) {
+    for (let i = 2; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--')
+            break;
+        if (arg === '--max-turns' || arg === '--max-tool-rounds') {
+            const value = argv[i + 1];
+            if (value === undefined)
+                continue;
+            parsePositiveIntegerOption(value, arg);
+            i++;
+            continue;
+        }
+        const eqIndex = arg?.indexOf('=') ?? -1;
+        if (eqIndex <= 0)
+            continue;
+        const optionName = arg.slice(0, eqIndex);
+        if (optionName === '--max-turns' || optionName === '--max-tool-rounds') {
+            parsePositiveIntegerOption(arg.slice(eqIndex + 1), optionName);
+        }
+    }
+}
+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)', value => parsePositiveIntegerOption(value, '--max-turns'))
+        .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', value => parsePositiveIntegerOption(value, '--max-tool-rounds'), 50)
+        .action(async (goal, options, command) => {
+        try {
+            const cwd = await prepareGoalCliWorkspace(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;
+            }
+            const judgeModel = resolveGoalCliJudgeModel(options.judgeModel);
+            const maxToolRounds = resolveGoalCliMaxToolRounds(options.maxToolRounds, command);
+            process.env.CODEBUDDY_DISABLE_MCP = process.env.CODEBUDDY_DISABLE_MCP ?? 'true';
+            process.env.CODEBUDDY_HEADLESS = 'true';
+            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, maxToolRounds, true, undefined, cwd, undefined, resolveLocalGoalActorSystemPrompt(resolved, cwd));
+            const result = await runGoalCommandWithAgent(agent, goal, {
+                provider: resolved,
+                judgeModel,
+                workingDirectory: cwd,
+                ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
+                onMessage: text => console.log(`\n${text}`),
+            });
+            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,34 @@
+import type { CodeBuddyClient } from '../../codebuddy/client.js';
+import { type GoalPlan } from '../../goals/goal-decomposer.js';
+import { CommandHandlerResult } from './branch-handlers.js';
+export interface GoalHandlerOptions {
+    sessionKey?: string;
+    client?: CodeBuddyClient | null;
+    planner?: (goal: string, client: CodeBuddyClient) => Promise<GoalPlan | null>;
+}
+/**
+ * /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[], options?: GoalHandlerOptions): 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[], options?: GoalHandlerOptions): Promise<CommandHandlerResult>;