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

package/dist/agent/session-end-flush.js

@@ -0,0 +1,217 @@
+/**
+ * Session-end flush (WS3-T1 — Mémoire & continuité du run).
+ *
+ * When a session ends, persist what the next run needs to not start from
+ * zero:
+ *  1. a short HANDOFF file (`.codebuddy/HANDOFF.md`) — last goal, last
+ *     state, files touched, open risks — written synchronously so it also
+ *     works from process `exit` handlers;
+ *  2. reusable lesson candidates via the existing review-gated
+ *     auto-proposer (PENDING only — a human approves them into lessons.md,
+ *     which the per-turn `<lessons_context>` injection then re-injects on
+ *     future runs).
+ *
+ * Guard-rails: trivial sessions are skipped (no LLM call, no file), and
+ * everything written here passes the privacy lint first (PII/secret spans
+ * are redacted from the handoff; tainted lesson candidates are dropped by
+ * the proposer itself).
+ *
+ * @module agent/session-end-flush
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { isFeatureEnabled } from '../config/feature-flags.js';
+import { redactSecrets } from '../fleet/privacy-lint.js';
+import { logger } from '../utils/logger.js';
+// ============================================================================
+// Gates & heuristics
+// ============================================================================
+/** Below this many assistant turns the session is too trivial to flush. */
+const MIN_ASSISTANT_TURNS = 2;
+/** Handoff is only worth writing past this transcript size (chars) … */
+const HANDOFF_MIN_TRANSCRIPT_CHARS = 8_000;
+/** … unless open risks were detected, which always deserve a handoff. */
+const RISK_PATTERN = /\b(error|failed|failure|exception|denied|timeout|timed out|blocked|fatal|refused)\b/i;
+const MAX_RISKS = 5;
+const SNIPPET_MAX = 240;
+function meaningfulTurns(history) {
+    let assistant = 0;
+    let tools = 0;
+    for (const e of history) {
+        if (e.type === 'assistant' && e.content.trim())
+            assistant++;
+        else if (e.type === 'tool_result')
+            tools++;
+    }
+    return { assistant, tools };
+}
+function firstLine(text) {
+    const line = text.trim().split('\n')[0] ?? '';
+    return line.length > SNIPPET_MAX ? `${line.slice(0, SNIPPET_MAX)}…` : line;
+}
+/**
+ * Heuristic open-risk extraction: error-ish tool results, deduped per tool,
+ * newest kept. No LLM involved — deterministic and free.
+ */
+export function extractOpenRisks(history) {
+    const byKey = new Map();
+    for (const e of history) {
+        if (e.type !== 'tool_result')
+            continue;
+        if (!RISK_PATTERN.test(e.content))
+            continue;
+        const tool = e.toolCall?.function?.name || 'tool';
+        byKey.set(tool, `\`${tool}\`: ${firstLine(redactSecrets(e.content))}`);
+    }
+    return [...byKey.values()].slice(-MAX_RISKS);
+}
+/** Files touched through write-ish tool calls, for the handoff. */
+export function extractTouchedFiles(history) {
+    const WRITE_TOOLS = new Set([
+        'str_replace', 'str_replace_editor', 'create_file', 'write_file',
+        'apply_patch', 'edit_file', 'text_editor',
+    ]);
+    const files = new Set();
+    for (const e of history) {
+        const calls = e.toolCalls ?? (e.toolCall ? [e.toolCall] : []);
+        for (const call of calls) {
+            if (!call?.function?.name || !WRITE_TOOLS.has(call.function.name))
+                continue;
+            try {
+                const args = JSON.parse(call.function.arguments || '{}');
+                const p = args.path ?? args.file_path ?? args.filePath;
+                if (typeof p === 'string' && p.trim())
+                    files.add(p.trim());
+            }
+            catch { /* unparseable args — skip */ }
+        }
+    }
+    return [...files].slice(0, 20);
+}
+// ============================================================================
+// Handoff (sync — usable from process exit handlers)
+// ============================================================================
+let handoffWrittenFor = null;
+/**
+ * Write `.codebuddy/HANDOFF.md` synchronously. Returns the path when
+ * written, undefined when the session didn't warrant one. Idempotent per
+ * history array so the async flush and a process-exit fallback don't both
+ * write.
+ */
+export function writeHandoffSync(history, workDir = process.cwd(), options = {}) {
+    if (handoffWrittenFor === history)
+        return undefined;
+    const { assistant } = meaningfulTurns(history);
+    if (assistant < MIN_ASSISTANT_TURNS)
+        return undefined;
+    const transcriptChars = history.reduce((n, e) => n + e.content.length, 0);
+    const risks = extractOpenRisks(history);
+    if (!options.force && transcriptChars < HANDOFF_MIN_TRANSCRIPT_CHARS && risks.length === 0) {
+        return undefined;
+    }
+    const lastUser = [...history].reverse().find((e) => e.type === 'user' && e.content.trim());
+    const lastAssistant = [...history].reverse().find((e) => e.type === 'assistant' && e.content.trim());
+    const touched = extractTouchedFiles(history);
+    const startedAt = options.startedAt;
+    const durationMin = startedAt ? Math.round((Date.now() - startedAt) / 60_000) : undefined;
+    const lines = [
+        '# Session Handoff',
+        '',
+        `> Auto-generated at session end — latest session wins. Read this before resuming work.`,
+        '',
+        `- Date: ${new Date().toISOString()}`,
+        ...(options.sessionId ? [`- Session: ${options.sessionId}`] : []),
+        ...(durationMin !== undefined ? [`- Durée: ~${durationMin} min`] : []),
+        `- Échanges: ${meaningfulTurns(history).assistant} réponses assistant, ${meaningfulTurns(history).tools} résultats d'outils`,
+        '',
+        '## Dernier objectif (utilisateur)',
+        '',
+        lastUser ? firstLine(redactSecrets(lastUser.content)) : '(aucun message utilisateur)',
+        '',
+        '## Dernier état (assistant)',
+        '',
+        lastAssistant ? redactSecrets(lastAssistant.content).trim().slice(0, 800) : '(aucune réponse)',
+        '',
+    ];
+    if (touched.length > 0) {
+        lines.push('## Fichiers touchés', '', ...touched.map((f) => `- \`${f}\``), '');
+    }
+    lines.push('## Risques ouverts', '');
+    if (risks.length > 0) {
+        lines.push(...risks.map((r) => `- ${r}`));
+    }
+    else {
+        lines.push('- Aucun détecté.');
+    }
+    lines.push('', '## Reprise', '', risks.length > 0
+        ? '- Commencer par lever les risques ouverts ci-dessus.'
+        : '- Continuer le dernier objectif, ou `buddy --continue` pour recharger la session.', '- Leçons en attente de revue : `buddy lessons` (candidats proposés en fin de session).', '');
+    const content = redactSecrets(lines.join('\n'));
+    const dir = path.join(workDir, '.codebuddy');
+    const target = path.join(dir, 'HANDOFF.md');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(target, content, 'utf8');
+        handoffWrittenFor = history;
+        return target;
+    }
+    catch (err) {
+        logger.debug('[session-end-flush] handoff write failed', { err: String(err) });
+        return undefined;
+    }
+}
+// ============================================================================
+// Full async flush (handoff + lesson proposal)
+// ============================================================================
+/**
+ * Run the complete session-end flush. Safe to call from any exit path:
+ * no-ops on trivial sessions, never throws.
+ */
+export async function runSessionEndFlush(input) {
+    const empty = { proposedLessons: 0, openRisks: [] };
+    try {
+        if (!isFeatureEnabled('SESSION_END_FLUSH')) {
+            return { ...empty, skipped: 'disabled' };
+        }
+        const history = input.chatHistory ?? [];
+        const { assistant } = meaningfulTurns(history);
+        if (assistant < MIN_ASSISTANT_TURNS) {
+            return { ...empty, skipped: 'trivial' };
+        }
+        const workDir = input.workDir ?? process.cwd();
+        const openRisks = extractOpenRisks(history);
+        const handoffPath = writeHandoffSync(history, workDir, {
+            ...(input.sessionId !== undefined ? { sessionId: input.sessionId } : {}),
+            ...(input.startedAt !== undefined ? { startedAt: input.startedAt } : {}),
+        });
+        // Lesson proposal last — it is the only step that may call an LLM, so a
+        // killed process still leaves the handoff behind.
+        let proposedLessons = 0;
+        try {
+            const { proposeLessonsFromSession } = await import('./lesson-auto-proposer.js');
+            const proposed = await proposeLessonsFromSession(history, workDir, input.client);
+            proposedLessons = proposed.length;
+        }
+        catch (err) {
+            logger.debug('[session-end-flush] lesson proposal failed', { err: String(err) });
+        }
+        if (proposedLessons > 0 || handoffPath) {
+            logger.info(`[session-end-flush] ${proposedLessons} lesson candidate(s) proposed` +
+                (handoffPath ? `, handoff written to ${path.relative(workDir, handoffPath)}` : ''));
+        }
+        return {
+            proposedLessons,
+            ...(handoffPath ? { handoffPath } : {}),
+            openRisks,
+        };
+    }
+    catch (err) {
+        logger.debug('[session-end-flush] flush failed', { err: String(err) });
+        return empty;
+    }
+}
+/** Test hook: reset the per-history idempotence latch. */
+export function resetSessionEndFlushState() {
+    handoffWrittenFor = null;
+}
+//# sourceMappingURL=session-end-flush.js.map

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

@@ -1762,7 +1762,7 @@ function registerHermesClawCommands(hermes) {
         .option('--timeout-ms <ms>', 'WebSocket validation timeout', '5000')
         .option('--openclaw-bin <path>', 'OpenClaw CLI binary path used for local install evidence')
         .option('--skip-cli-status', 'skip openclaw gateway status --json validation')
-        .option('--skip-pending-nodes', 'skip the nodes.pending read-only validation call')
+        .option('--skip-pending-nodes', 'skip the node.pair.list read-only validation call')
         .option('--approved-by <name>', 'operator approving live upstream validation')
         .option('--apply', 'contact the OpenClaw Gateway WebSocket (otherwise dry-run)')
         .option('--yes', 'confirm live validation when used with --apply')

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

@@ -817,6 +817,8 @@ 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) => {
@@ -828,12 +830,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 } : {}),
+            ...(opts.goalMaxTurns ? { goalMaxTurns: parseInt(opts.goalMaxTurns, 10) } : {}),
         });
         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>')
@@ -969,6 +974,36 @@ export function registerFleetAutonomyCommands(program) {
         console.log(`  Manage:    systemctl --user status|stop|start|restart codebuddy-autonomy`);
         console.log(`  Remove:    buddy autonomy uninstall`);
     });
+    fleet
+        .command('service <action>')
+        .description('Control the installed autonomy service: start | stop | restart | status')
+        .option('--json', 'output JSON')
+        .action(async (action, opts) => {
+        const { ServiceInstaller } = await import('../../daemon/service-installer.js');
+        const installer = new ServiceInstaller({ serviceName: 'codebuddy-autonomy' });
+        if (action === 'status') {
+            const status = await installer.status();
+            if (opts.json) {
+                console.log(JSON.stringify({ status }, null, 2));
+                return;
+            }
+            console.log(`Autonomy service (${status.platform}): ${status.installed ? (status.running ? 'running' : 'installed, stopped') : 'not installed'}`);
+            return;
+        }
+        if (action !== 'start' && action !== 'stop' && action !== 'restart') {
+            console.error(`Invalid action "${action}" (use start|stop|restart|status).`);
+            process.exit(1);
+            return;
+        }
+        const result = await installer.control(action);
+        if (opts.json) {
+            console.log(JSON.stringify({ result }, null, 2));
+            return;
+        }
+        console.log(result.success ? `Autonomy service ${action}: ok (${result.platform})` : `Failed to ${action}: ${result.error}`);
+        if (!result.success)
+            process.exit(1);
+    });
     fleet
         .command('uninstall')
         .description('Remove the autonomous daemon systemd service')

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)],
+        ['__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/flow.js

@@ -8,8 +8,7 @@
  *   buddy flow "Refactor the API layer" --max-retries 2
  */
 import { Command } from 'commander';
-import { getSettingsManager } from '../utils/settings-manager.js';
-import { PROVIDERS } from './provider.js';
+import { resolveCommandProvider } from './llm-provider-resolution.js';
 function extractContent(response) {
     return response.choices?.[0]?.message?.content || '';
 }
@@ -20,24 +19,21 @@ export function createFlowCommand() {
         .option('--max-retries <n>', 'Max retries per failed step', '1')
         .option('--default-agent <key>', 'Default agent key', 'default')
         .option('--verbose', 'Show step-by-step progress', false)
-        .action(async (goal, options) => {
-        const settingsManager = getSettingsManager();
-        const userSettings = settingsManager.loadUserSettings();
-        const currentProviderKey = userSettings.provider || 'grok';
-        const providerInfo = PROVIDERS[currentProviderKey];
-        let apiKey = process.env[providerInfo?.envVar || ''] || '';
-        if (!apiKey)
-            apiKey = process.env.GROK_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || '';
-        if (!apiKey) {
-            console.error('Error: No API key configured. Run: buddy onboard');
+        .option('-m, --model <model>', 'Override the model for this flow run')
+        .action(async (goal, options, 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 = 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);
         }
         console.log(`\n  Planning Flow: "${goal}"\n`);
         try {
             const { PlanningFlow } = await import('../agent/flow/planning-flow.js');
             const { CodeBuddyClient } = await import('../codebuddy/client.js');
-            const model = settingsManager.getCurrentModel() || providerInfo?.defaultModel;
-            const client = new CodeBuddyClient(apiKey, model, providerInfo?.baseURL);
+            const client = new CodeBuddyClient(resolved.apiKey, resolved.model, resolved.baseURL);
             // Plan with LLM function
             const planWithLLM = async (prompt) => {
                 const response = await client.chat([

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

@@ -0,0 +1,41 @@
+/**
+ * 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 { 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 GoalLoopRunOptions {
+    maxTurns?: number;
+    /** Progress sink (status lines ⊙/↻/✓/⏸). Defaults to silent. */
+    onMessage?: (text: string) => void;
+}
+export interface GoalLoopRunResult {
+    status: GoalStatus | 'unknown';
+    turnsUsed: number;
+    lastReason?: string;
+}
+/**
+ * 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>;
+export declare function createGoalCommand(): Command;

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