@phuetz/code-buddy 1.0.0 → 1.1.0

package/dist/goals/goal-state.js

@@ -0,0 +1,245 @@
+/**
+ * Persistent session goals — the Ralph loop for Code Buddy.
+ *
+ * A goal is a free-form user objective that stays active across turns. After
+ * each turn completes, a small judge call asks an auxiliary model "is this
+ * goal satisfied by the assistant's last response?". If not, Code Buddy feeds
+ * a continuation prompt back into the same session and keeps working until
+ * the goal is done, the turn budget is exhausted, the user pauses/clears it,
+ * or a real user message preempts the loop.
+ *
+ * Ported from Hermes Agent's goal system (hermes_cli/goals.py). Invariants:
+ * - The continuation prompt is a plain user message — no system-prompt
+ *   mutation, no toolset swap, prompt caching stays intact.
+ * - Judge failures are fail-OPEN ("continue"): a broken judge must not wedge
+ *   progress; the turn budget is the backstop.
+ * - A real user message mid-loop preempts the continuation prompt; the judge
+ *   re-runs after that turn.
+ */
+// ──────────────────────────────────────────────────────────────────────
+// Constants & defaults
+// ──────────────────────────────────────────────────────────────────────
+export const DEFAULT_MAX_TURNS = 20;
+export const DEFAULT_JUDGE_TIMEOUT_MS = 30_000;
+// Judge output budget. The judge returns a one-line JSON verdict, but
+// reasoning models burn tokens on hidden reasoning before emitting the
+// visible JSON. Tight caps truncate the JSON and trip the auto-pause.
+export const DEFAULT_JUDGE_MAX_TOKENS = 4096;
+// Caps how much of the inputs we send to the judge.
+export const JUDGE_GOAL_SNIPPET_CHARS = 2000;
+export const JUDGE_SUBGOALS_SNIPPET_CHARS = 2000;
+export const JUDGE_RESPONSE_SNIPPET_CHARS = 4000;
+// After this many consecutive judge *parse* failures (empty output /
+// non-JSON), the loop auto-pauses and points the user at the judge config.
+// Guards against small models that can't follow the strict JSON contract.
+export const MAX_CONSECUTIVE_PARSE_FAILURES = 3;
+export const CONTINUATION_PROMPT_TEMPLATE = '[Continuing toward your standing goal]\n' +
+    'Goal: {goal}\n\n' +
+    'Continue working toward this goal. Take the next concrete step. ' +
+    'If you believe the goal is complete, state so explicitly and stop. ' +
+    'If you are blocked and need input from the user, say so clearly and stop.';
+export const CONTINUATION_PROMPT_WITH_SUBGOALS_TEMPLATE = '[Continuing toward your standing goal]\n' +
+    'Goal: {goal}\n\n' +
+    'Additional criteria the user added mid-loop:\n' +
+    '{subgoals_block}\n\n' +
+    'Continue working toward the goal AND all additional criteria. Take ' +
+    'the next concrete step. If you believe the goal and every ' +
+    'additional criterion are complete, state so explicitly and stop. ' +
+    'If you are blocked and need input from the user, say so clearly ' +
+    'and stop.';
+export const JUDGE_SYSTEM_PROMPT = "You are a strict judge evaluating whether an autonomous agent has " +
+    "achieved a user's stated goal. You receive the goal text and the " +
+    "agent's most recent response. Your only job is to decide whether " +
+    'the goal is fully satisfied based on that response.\n\n' +
+    'A goal is DONE only when:\n' +
+    '- The response explicitly confirms the goal was completed, OR\n' +
+    '- The response clearly shows the final deliverable was produced, OR\n' +
+    '- The response explains the goal is unachievable / blocked / needs ' +
+    'user input (treat this as DONE with reason describing the block).\n\n' +
+    'Otherwise the goal is NOT done — CONTINUE.\n\n' +
+    'Reply ONLY with a single JSON object on one line:\n' +
+    '{"done": <true|false>, "reason": "<one-sentence rationale>"}';
+export const JUDGE_USER_PROMPT_TEMPLATE = 'Goal:\n{goal}\n\n' +
+    "Agent's most recent response:\n{response}\n\n" +
+    'Current time: {current_time}\n\n' +
+    'Is the goal satisfied?';
+export const JUDGE_USER_PROMPT_WITH_SUBGOALS_TEMPLATE = 'Goal:\n{goal}\n\n' +
+    'Additional criteria the user added mid-loop (all must also be ' +
+    'satisfied for the goal to be DONE):\n{subgoals_block}\n\n' +
+    "Agent's most recent response:\n{response}\n\n" +
+    'Current time: {current_time}\n\n' +
+    'Decision: For each numbered criterion above, find concrete ' +
+    "evidence in the agent's response that the criterion is " +
+    "satisfied. Do not accept generic phrases like 'all requirements " +
+    "met' or 'implying it was done' — require specific evidence (a " +
+    'file contents excerpt, an output line, a command result). If ' +
+    'ANY criterion lacks specific evidence in the response, the goal ' +
+    'is NOT done — return CONTINUE.\n\n' +
+    'Is the goal AND every additional criterion satisfied?';
+// ──────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────
+export function truncateText(text, limit) {
+    if (!text)
+        return '';
+    if (text.length <= limit)
+        return text;
+    return text.slice(0, limit) + '… [truncated]';
+}
+/** Render subgoals as a numbered `- N. text` block. Empty string when none. */
+export function renderSubgoalsBlock(subgoals) {
+    if (!subgoals.length)
+        return '';
+    return subgoals.map((text, i) => `- ${i + 1}. ${text}`).join('\n');
+}
+export function createGoalState(goal, maxTurns = DEFAULT_MAX_TURNS) {
+    return {
+        goal,
+        status: 'active',
+        turnsUsed: 0,
+        maxTurns,
+        createdAt: Date.now(),
+        lastTurnAt: 0,
+        consecutiveParseFailures: 0,
+        subgoals: [],
+    };
+}
+/**
+ * Defensive deserialization of a persisted goal state. Returns null when the
+ * payload isn't a usable goal. Old payloads without `subgoals` load unchanged.
+ */
+export function normalizeGoalState(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const data = raw;
+    const goal = typeof data.goal === 'string' ? data.goal : '';
+    if (!goal.trim())
+        return null;
+    const status = ['active', 'paused', 'done', 'cleared'].includes(String(data.status))
+        ? data.status
+        : 'active';
+    const subgoals = Array.isArray(data.subgoals)
+        ? data.subgoals.map(s => String(s).trim()).filter(Boolean)
+        : [];
+    const verdict = ['done', 'continue', 'skipped'].includes(String(data.lastVerdict))
+        ? data.lastVerdict
+        : undefined;
+    const state = {
+        goal,
+        status,
+        turnsUsed: toInt(data.turnsUsed, 0),
+        maxTurns: toInt(data.maxTurns, DEFAULT_MAX_TURNS) || DEFAULT_MAX_TURNS,
+        createdAt: toNumber(data.createdAt, 0),
+        lastTurnAt: toNumber(data.lastTurnAt, 0),
+        consecutiveParseFailures: toInt(data.consecutiveParseFailures, 0),
+        subgoals,
+    };
+    if (verdict)
+        state.lastVerdict = verdict;
+    if (typeof data.lastReason === 'string')
+        state.lastReason = data.lastReason;
+    if (typeof data.pausedReason === 'string')
+        state.pausedReason = data.pausedReason;
+    return state;
+}
+function toInt(value, fallback) {
+    const n = Number(value);
+    return Number.isFinite(n) ? Math.trunc(n) : fallback;
+}
+function toNumber(value, fallback) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+/** Printable one-liner for /goal status. */
+export function formatGoalStatusLine(state) {
+    if (!state || state.status === 'cleared') {
+        return 'No active goal. Set one with /goal <text>.';
+    }
+    const turns = `${state.turnsUsed}/${state.maxTurns} turns`;
+    const sub = state.subgoals.length
+        ? `, ${state.subgoals.length} subgoal${state.subgoals.length !== 1 ? 's' : ''}`
+        : '';
+    if (state.status === 'active') {
+        return `⊙ Goal (active, ${turns}${sub}): ${state.goal}`;
+    }
+    if (state.status === 'paused') {
+        const extra = state.pausedReason ? ` — ${state.pausedReason}` : '';
+        return `⏸ Goal (paused, ${turns}${sub}${extra}): ${state.goal}`;
+    }
+    if (state.status === 'done') {
+        return `✓ Goal done (${turns}${sub}): ${state.goal}`;
+    }
+    return `Goal (${state.status}, ${turns}${sub}): ${state.goal}`;
+}
+/** The canonical user-role continuation message for an active goal. */
+export function buildContinuationPrompt(state) {
+    if (state.subgoals.length) {
+        return CONTINUATION_PROMPT_WITH_SUBGOALS_TEMPLATE.replace('{goal}', state.goal).replace('{subgoals_block}', renderSubgoalsBlock(state.subgoals));
+    }
+    return CONTINUATION_PROMPT_TEMPLATE.replace('{goal}', state.goal);
+}
+/**
+ * Apply a judge outcome to an active goal — the exact Hermes ladder.
+ * MUTATES `state` (turn counter, verdict bookkeeping, status transitions)
+ * and returns the decision; the caller persists the state wherever it
+ * lives (GoalStore file, peer-session record, …).
+ */
+export function applyJudgeOutcome(state, outcome, nowMs = Date.now()) {
+    state.turnsUsed += 1;
+    state.lastTurnAt = nowMs;
+    state.lastVerdict = outcome.verdict;
+    state.lastReason = outcome.reason;
+    // Reset the parse-failure streak on any usable reply, including
+    // API/transport errors (parseFailed=false), so a flaky network doesn't
+    // trip the auto-pause meant for bad judge models.
+    state.consecutiveParseFailures = outcome.parseFailed ? state.consecutiveParseFailures + 1 : 0;
+    if (outcome.verdict === 'done') {
+        state.status = 'done';
+        return {
+            status: 'done',
+            shouldContinue: false,
+            continuationPrompt: null,
+            verdict: 'done',
+            reason: outcome.reason,
+            message: `✓ Goal achieved: ${outcome.reason}`,
+        };
+    }
+    if (state.consecutiveParseFailures >= MAX_CONSECUTIVE_PARSE_FAILURES) {
+        state.status = 'paused';
+        state.pausedReason = `judge model returned unparseable output ${state.consecutiveParseFailures} turns in a row`;
+        return {
+            status: 'paused',
+            shouldContinue: false,
+            continuationPrompt: null,
+            verdict: 'continue',
+            reason: outcome.reason,
+            message: `⏸ Goal paused — the judge model (${state.consecutiveParseFailures} turns) ` +
+                'isn\'t returning the required JSON verdict. Route the judge to a stricter ' +
+                'model in .codebuddy/settings.json:\n' +
+                '  { "goals": { "judgeModel": "<a model that follows JSON instructions>" } }\n' +
+                'Then /goal resume to continue.',
+        };
+    }
+    if (state.turnsUsed >= state.maxTurns) {
+        state.status = 'paused';
+        state.pausedReason = `turn budget exhausted (${state.turnsUsed}/${state.maxTurns})`;
+        return {
+            status: 'paused',
+            shouldContinue: false,
+            continuationPrompt: null,
+            verdict: 'continue',
+            reason: outcome.reason,
+            message: `⏸ Goal paused — ${state.turnsUsed}/${state.maxTurns} turns used. ` +
+                'Use /goal resume to keep going, or /goal clear to stop.',
+        };
+    }
+    return {
+        status: 'active',
+        shouldContinue: true,
+        continuationPrompt: buildContinuationPrompt(state),
+        verdict: 'continue',
+        reason: outcome.reason,
+        message: `↻ Continuing toward goal (${state.turnsUsed}/${state.maxTurns}): ${outcome.reason}`,
+    };
+}
+//# sourceMappingURL=goal-state.js.map

package/dist/goals/goal-store.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Durable per-session goal persistence.
+ *
+ * One JSON file per session key under `~/.codebuddy/goals/` (honors
+ * CODEBUDDY_HOME). Files are tiny (<1 KB) so I/O is synchronous — same
+ * trade-off as TodoTracker. Writes are atomic (tmp + rename). Loads are
+ * fail-soft: a corrupt or unreadable file reads as "no goal".
+ *
+ * Cleared goals keep a tombstone (`status: 'cleared'`) for audit, mirroring
+ * Hermes' SessionDB behavior.
+ */
+import { GoalState } from './goal-state.js';
+export interface GoalStoreOptions {
+    /** Override the storage directory (test isolation). */
+    storeDir?: string;
+}
+export declare class GoalStore {
+    private storeDir;
+    constructor(options?: GoalStoreOptions);
+    getStoreDir(): string;
+    load(key: string): GoalState | null;
+    save(key: string, state: GoalState): void;
+    delete(key: string): void;
+    private fileFor;
+}

package/dist/goals/goal-store.js

@@ -0,0 +1,71 @@
+/**
+ * Durable per-session goal persistence.
+ *
+ * One JSON file per session key under `~/.codebuddy/goals/` (honors
+ * CODEBUDDY_HOME). Files are tiny (<1 KB) so I/O is synchronous — same
+ * trade-off as TodoTracker. Writes are atomic (tmp + rename). Loads are
+ * fail-soft: a corrupt or unreadable file reads as "no goal".
+ *
+ * Cleared goals keep a tombstone (`status: 'cleared'`) for audit, mirroring
+ * Hermes' SessionDB behavior.
+ */
+import fs from 'fs';
+import path from 'path';
+import { getCodeBuddyPath } from '../utils/codebuddy-home.js';
+import { logger } from '../utils/logger.js';
+import { normalizeGoalState } from './goal-state.js';
+export class GoalStore {
+    storeDir;
+    constructor(options = {}) {
+        this.storeDir = options.storeDir ?? getCodeBuddyPath('goals');
+    }
+    getStoreDir() {
+        return this.storeDir;
+    }
+    load(key) {
+        if (!key)
+            return null;
+        const file = this.fileFor(key);
+        try {
+            if (!fs.existsSync(file))
+                return null;
+            const raw = fs.readFileSync(file, 'utf-8');
+            return normalizeGoalState(JSON.parse(raw));
+        }
+        catch (error) {
+            logger.debug('GoalStore: failed to load goal state', { key, error: String(error) });
+            return null;
+        }
+    }
+    save(key, state) {
+        if (!key)
+            return;
+        const file = this.fileFor(key);
+        try {
+            fs.mkdirSync(this.storeDir, { recursive: true });
+            const tmp = `${file}.tmp.${process.pid}`;
+            fs.writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf-8');
+            fs.renameSync(tmp, file);
+        }
+        catch (error) {
+            logger.debug('GoalStore: failed to save goal state', { key, error: String(error) });
+        }
+    }
+    delete(key) {
+        if (!key)
+            return;
+        try {
+            fs.rmSync(this.fileFor(key), { force: true });
+        }
+        catch (error) {
+            logger.debug('GoalStore: failed to delete goal state', { key, error: String(error) });
+        }
+    }
+    fileFor(key) {
+        // Session ids and dir-hash keys are already filesystem-safe; sanitize
+        // anyway so a malformed key can't escape the store directory.
+        const safe = key.replace(/[^a-zA-Z0-9._-]/g, '_');
+        return path.join(this.storeDir, `${safe}.json`);
+    }
+}
+//# sourceMappingURL=goal-store.js.map

package/dist/goals/index.d.ts

@@ -0,0 +1,5 @@
+export * from './goal-state.js';
+export * from './goal-store.js';
+export * from './goal-judge.js';
+export * from './goal-manager.js';
+export * from './goal-loop.js';

package/dist/goals/index.js

@@ -0,0 +1,6 @@
+export * from './goal-state.js';
+export * from './goal-store.js';
+export * from './goal-judge.js';
+export * from './goal-manager.js';
+export * from './goal-loop.js';
+//# sourceMappingURL=index.js.map

package/dist/hooks/use-input-handler.js

@@ -16,6 +16,7 @@ import { ClientCommandDispatcher } from "../commands/client-dispatcher.js";
 import { extractFileReference, getFileSuggestions } from "../ui/components/FileAutocomplete.js";
 // Import interaction logger for session tracking
 import { getInteractionLogger } from "../logging/interaction-logger.js";
+import { maybeContinueGoalAfterTurn } from "../goals/goal-loop.js";
 import { logger } from '../utils/logger.js';
 // Import history manager for persistent command history
 import { getHistoryManager } from "../utils/history-manager.js";
@@ -35,6 +36,11 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
     // Track last escape time for double-escape detection
     const lastEscapeTimeRef = useRef(0);
     const DOUBLE_ESCAPE_THRESHOLD = 500; // ms
+    // Goal loop (Ralph loop): monotonically increasing turn sequence. A real
+    // user submit mid-turn bumps it, which voids the stale turn's continuation
+    // (the judge then runs after the user's turn instead — Hermes preemption).
+    const turnSeqRef = useRef(0);
+    const goalInterruptedRef = useRef(false);
     /**
      * Save instruction to .codebuddyrules file (Standard # capture)
      */
@@ -88,6 +94,7 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
             return true;
         }
         if (isProcessing || isStreaming) {
+            goalInterruptedRef.current = true;
             agent.abortCurrentOperation();
             setIsProcessing(false);
             setIsStreaming(false);
@@ -465,6 +472,8 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         return await ClientCommandDispatcher.dispatch(input, context);
     };
     const processUserMessage = async (userInput) => {
+        const mySeq = ++turnSeqRef.current;
+        goalInterruptedRef.current = false;
         const userEntry = {
             type: "user",
             content: userInput,
@@ -484,10 +493,10 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         setIsProcessing(true);
         setCurrentActivity?.('Sending to LLM...');
         clearInput();
+        let fullResponseContent = "";
         try {
             setIsStreaming(true);
             let streamingEntry = null;
-            let fullResponseContent = "";
             for await (const chunk of agent.processUserMessageStream(userInput)) {
                 switch (chunk.type) {
                     case "content":
@@ -677,6 +686,32 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         setIsProcessing(false);
         setCurrentActivity?.('');
         processingStartTime.current = 0;
+        // Goal loop (Ralph loop): judge the finished turn and maybe auto-continue.
+        // Failures here must never break a turn — the goal system is advisory.
+        try {
+            const outcome = await maybeContinueGoalAfterTurn({
+                client: agent.getClient(),
+                lastResponse: fullResponseContent,
+                interrupted: goalInterruptedRef.current,
+            });
+            if (outcome?.message) {
+                setChatHistory((prev) => [
+                    ...prev,
+                    { type: 'assistant', content: outcome.message, timestamp: new Date() },
+                ]);
+            }
+            // Skip the continuation if a newer turn started while we were judging —
+            // the user's message preempts the loop and gets judged after its turn.
+            if (outcome?.continuationPrompt && turnSeqRef.current === mySeq) {
+                const continuation = outcome.continuationPrompt;
+                setTimeout(() => {
+                    void processUserMessage(continuation);
+                }, 50);
+            }
+        }
+        catch (error) {
+            logger.debug('goal after-turn hook failed', { error: String(error) });
+        }
     };
     return {
         input,

package/dist/index.js

@@ -728,6 +728,20 @@ async function processPromptHeadless(prompt, apiKey, baseURL, model, maxToolRoun
         }
         // Process the user message
         const chatEntries = await agent.processUserMessage(prompt);
+        // WS3-T1 — session-end flush (handoff + lesson candidates). Awaited with
+        // a hard cap so headless runs keep their continuity write without ever
+        // hanging the exit; trivial sessions no-op inside the module.
+        try {
+            const { runSessionEndFlush } = await import('./agent/session-end-flush.js');
+            const flushTimeoutMs = parseInt(process.env.CODEBUDDY_SESSION_END_FLUSH_TIMEOUT_MS || '15000', 10);
+            await Promise.race([
+                runSessionEndFlush({ chatHistory: chatEntries }),
+                new Promise((resolve) => setTimeout(resolve, flushTimeoutMs).unref()),
+            ]);
+        }
+        catch (e) {
+            logger.debug('Headless session-end flush skipped', { error: String(e) });
+        }
         // Log entries to interaction logger
         if (interactionLogger) {
             for (const entry of chatEntries) {
@@ -1520,6 +1534,9 @@ program
                     tags: ['interactive'],
                 });
                 agent.__interactionLogger = interactionLogger;
+                // WS3-T1 — pre-load the flush module so the sync `exit` handler
+                // can call it (ESM has no require; dynamic import is async).
+                const sessionEndFlush = await import('./agent/session-end-flush.js');
                 const cleanup = () => {
                     try {
                         interactionLogger.endSession();
@@ -1527,10 +1544,30 @@ program
                     catch (e) {
                         logger.debug('Failed to end interaction logger session', { error: String(e) });
                     }
+                    // `exit` handlers are sync-only: write at least the handoff
+                    // (no LLM) so an interrupted session still leaves a resume
+                    // point. The full async flush runs on SIGINT/SIGTERM below.
+                    try {
+                        sessionEndFlush.writeHandoffSync(agent.getChatHistory());
+                    }
+                    catch { /* handoff is best-effort on hard exit */ }
+                };
+                const flushThenExit = () => {
+                    cleanup();
+                    void (async () => {
+                        try {
+                            await Promise.race([
+                                sessionEndFlush.runSessionEndFlush({ chatHistory: agent.getChatHistory() }),
+                                new Promise((resolve) => setTimeout(resolve, 8000).unref()),
+                            ]);
+                        }
+                        catch { /* never block exit on the flush */ }
+                        process.exit(0);
+                    })();
                 };
                 process.on('exit', cleanup);
-                process.on('SIGINT', () => { cleanup(); process.exit(0); });
-                process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+                process.on('SIGINT', flushThenExit);
+                process.on('SIGTERM', flushThenExit);
             }
             catch (err) {
                 logger.warn('Failed to initialize interaction logger', { error: String(err) });
@@ -2045,6 +2082,11 @@ addLazyCommand(program, 'flow', 'Execute a multi-agent planning flow (OpenManus-
     const { createFlowCommand } = await import('./commands/flow.js');
     return createFlowCommand();
 });
+// Goal Ralph loop — headless judge-gated auto-continue (Hermes Agent parity)
+addLazyCommand(program, 'goal', 'Run the agent toward a standing goal until a judge model confirms it is done (Ralph loop)', async () => {
+    const { createGoalCommand } = await import('./commands/goal-cli.js');
+    return createGoalCommand();
+});
 // Todo attention bias — Manus AI-inspired persistent task list
 addLazyCommand(program, 'todo', 'Manage persistent task list (todo.md) — injected at end of every agent turn for focus', async () => {
     const { createTodosCommand } = await import('./commands/todos.js');

package/dist/observability/run-store.d.ts

@@ -9,7 +9,7 @@
  * Written in append mode for performance — no full-file parsing per event.
  * Automatic pruning keeps the 30 most recent runs.
  */
-export type RunEventType = 'run_start' | 'run_end' | 'step_start' | 'step_end' | 'tool_call' | 'tool_result' | 'patch_created' | 'patch_applied' | 'decision' | 'error' | 'metric' | 'lesson_added' | 'lesson_candidate_proposed' | 'skill_selected';
+export type RunEventType = 'run_start' | 'run_end' | 'step_start' | 'step_end' | 'tool_call' | 'tool_result' | 'patch_created' | 'patch_applied' | 'decision' | 'error' | 'metric' | 'lesson_added' | 'lesson_candidate_proposed' | 'skill_selected' | 'context_snapshot' | 'pause_suggested';
 export interface RunEvent {
     ts: number;
     type: RunEventType;

package/dist/server/websocket/fleet-bridge.d.ts

@@ -38,7 +38,7 @@
  * agent-executor events so receivers can map them 1:1 to local
  * AgentRuntime events for re-display.
  */
-export declare const FLEET_EVENT_TYPES: readonly ["fleet:agent:tool_started", "fleet:agent:tool_completed", "fleet:agent:tool_error", "fleet:agent:reasoning", "fleet:workflow:event", "fleet:workflow:start", "fleet:workflow:complete", "fleet:session:spawn", "fleet:session:message", "fleet:peer:heartbeat", "fleet:peer:compacting:start", "fleet:peer:compacting:complete", "fleet:chat-session:start", "fleet:chat-session:turn", "fleet:chat-session:end"];
+export declare const FLEET_EVENT_TYPES: readonly ["fleet:agent:tool_started", "fleet:agent:tool_completed", "fleet:agent:tool_error", "fleet:agent:reasoning", "fleet:workflow:event", "fleet:workflow:start", "fleet:workflow:complete", "fleet:session:spawn", "fleet:session:message", "fleet:peer:heartbeat", "fleet:peer:compacting:start", "fleet:peer:compacting:complete", "fleet:chat-session:start", "fleet:chat-session:turn", "fleet:chat-session:end", "fleet:chat-session:goal"];
 export type FleetEventType = (typeof FLEET_EVENT_TYPES)[number];
 /**
  * Source identification carried with every fleet event so receivers know
@@ -137,3 +137,15 @@ export declare function broadcastChatSessionEnd(payload: {
     sessionId: string;
     reason?: 'end' | 'expired';
 }): void;
+/**
+ * Goal Ralph-loop on a peer session (Hermes gateway parity) — emitted on
+ * goal attach/pause/resume/clear and after each post-turn judge verdict.
+ * Metadata only: status/verdict/counters, never goal text or judge reasons.
+ */
+export declare function broadcastChatSessionGoal(payload: {
+    sessionId: string;
+    status: string;
+    verdict?: string;
+    turnsUsed?: number;
+    maxTurns?: number;
+}): void;

package/dist/server/websocket/fleet-bridge.js

@@ -67,6 +67,9 @@ export const FLEET_EVENT_TYPES = [
     'fleet:chat-session:start',
     'fleet:chat-session:turn',
     'fleet:chat-session:end',
+    // Goal Ralph-loop on peer sessions (Hermes gateway parity). Metadata
+    // only — status/verdict/turn counters, never goal text or reasons.
+    'fleet:chat-session:goal',
 ];
 /**
  * Cached source. Resolved lazily on first emit so tests can stub
@@ -167,4 +170,12 @@ export function broadcastChatSessionTurn(payload) {
 export function broadcastChatSessionEnd(payload) {
     broadcastFleetEvent('fleet:chat-session:end', { ...payload });
 }
+/**
+ * Goal Ralph-loop on a peer session (Hermes gateway parity) — emitted on
+ * goal attach/pause/resume/clear and after each post-turn judge verdict.
+ * Metadata only: status/verdict/counters, never goal text or judge reasons.
+ */
+export function broadcastChatSessionGoal(payload) {
+    broadcastFleetEvent('fleet:chat-session:goal', { ...payload });
+}
 //# sourceMappingURL=fleet-bridge.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phuetz/code-buddy",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Open-source multi-provider AI coding agent for the terminal. Supports Grok, Claude, ChatGPT, Gemini, Ollama and LM Studio with 52+ tools, multi-channel messaging, skills system, and Enterprise-grade architecture.",
   "author": "Patrice Huetz <patrice.huetz@gmail.com>",
   "repository": {