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

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/mcp/client.js

@@ -41,6 +41,18 @@ export class MCPManager extends EventEmitter {
             // Connect
             const sdkTransport = await transport.connect();
             await client.connect(sdkTransport);
+            // Drain the captured MCP stderr to the logger. The stream only exists
+            // for stdio transports created with stderr:'pipe' (see StdioTransport);
+            // without a consumer the PassThrough back-pressures the child once its
+            // buffer fills, so this drain is load-bearing — not just cosmetic.
+            const stderrStream = sdkTransport.stderr;
+            if (stderrStream) {
+                stderrStream.on('data', (chunk) => {
+                    const text = chunk.toString().trim();
+                    if (text)
+                        logger.debug(`[MCP:${config.name}] ${text}`);
+                });
+            }
             // List available tools
             const toolsResult = await client.listTools();
             // Register tools

package/dist/mcp/transports.js

@@ -26,6 +26,11 @@ export class StdioTransport {
             command: this.config.command,
             args: this.config.args || [],
             env,
+            // The SDK default is stderr:'inherit', which lets a noisy MCP server
+            // (startup banners, progress logs) write raw bytes into the CLI's own
+            // stderr — breaking the --quiet/pipeable-JSON headless contract.
+            // Capture it instead; client.ts drains the stream to logger.debug.
+            stderr: 'pipe',
         };
         try {
             this.transport = new StdioClientTransport(transportConfig);

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/openclaw/gateway-bridge.d.ts

@@ -317,7 +317,7 @@ export interface OpenClawWebSocketProbeRecord {
     liveProbeConfirmed: boolean;
     status: 'preview' | 'connected' | 'blocked' | 'failed';
     request: {
-        connectFrameType: 'connect';
+        connectFrameType: 'req/connect';
         statusMethod: string;
         requestId: string;
     };