@openeryc/pi-coding-agent 0.75.58 → 0.75.59

package/dist/modes/interactive/interactive-mode.js

@@ -62,7 +62,7 @@ import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
-import { isNearDuplicateGoalOutput, normalizeGoalOutput } from "./goal-runner-utils.js";
+import { evaluateGoalCondition } from "./goal-evaluator.js";
 import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
 function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
@@ -182,13 +182,12 @@ export class InteractiveMode {
     goalRunnerAbortController = undefined;
     goalRunnerRetryAttempt = 0;
     goalRunnerStatusDisplayed = false;
-    /** Normalized assistant texts from recent goal turns (for duplicate detection). */
-    goalRunnerRecentOutputs = [];
-    GOAL_RUNNER_MAX_RETRIES = 10;
-    GOAL_RUNNER_BASE_DELAY_MS = 3000;
-    GOAL_RUNNER_TURN_DELAY_MS = 800;
-    /** Pause when this many consecutive turns look like near-duplicates. */
-    GOAL_RUNNER_MAX_DUPLICATE_STREAK = 3;
+    goalRunnerTurnCount = 0;
+    goalRunnerStartTime = 0;
+    goalRunnerTokenSpend = 0;
+    goalRunnerLastEvalReason = "";
+    GOAL_RUNNER_TURN_DELAY_MS = 1200;
+    GOAL_RUNNER_RETRY_DELAY_MS = 5000;
     // Extension UI state
     extensionSelector = undefined;
     extensionInput = undefined;
@@ -2077,8 +2076,10 @@ export class InteractiveMode {
             // Handle commands (with special case for /goal which continues to submit)
             if (text.startsWith("/goal")) {
                 const goal = text.replace(/^\/goal\s*/, "").trim();
-                this.handleGoalCommand(text);
+                const shouldSubmit = await this.handleGoalCommand(text);
                 this.editor.setText("");
+                if (!shouldSubmit)
+                    return;
                 if (goal)
                     text = goal;
             }
@@ -4593,64 +4594,115 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${name}`), 1, 0));
         this.ui.requestRender();
     }
-    handleGoalCommand(text) {
+    async handleGoalCommand(text) {
         const goal = text.replace(/^\/goal\s*/, "").trim();
         if (!goal) {
+            // Show goal status (like Claude Code's /goal with no args)
             const currentGoal = this.session.sessionGoal;
-            const runnerStatus = this.goalRunnerEnabled ? "enabled" : "paused";
-            if (currentGoal) {
+            if (!currentGoal) {
+                this.showWarning("Usage: /goal <condition>\n  /goal clear|stop|off|reset|cancel  - clear goal");
+                this.ui.requestRender();
+                return false;
+            }
+            const elapsed = this.goalRunnerStartTime > 0 ? this.formatDuration(Date.now() - this.goalRunnerStartTime) : "-";
+            const turns = this.goalRunnerTurnCount > 0 ? String(this.goalRunnerTurnCount) : "-";
+            const tokens = this.goalRunnerTokenSpend > 0 ? `${this.goalRunnerTokenSpend.toLocaleString()} tokens` : "-";
+            let info = `${theme.bold(theme.fg("accent", "Session Goal"))}\n\n`;
+            info += `${theme.fg("dim", "Condition:")} ${currentGoal}\n`;
+            info += `${theme.fg("dim", "Running:")} ${elapsed}\n`;
+            info += `${theme.fg("dim", "Turns:")} ${turns}\n`;
+            info += `${theme.fg("dim", "Tokens:")} ${tokens}\n`;
+            if (this.goalRunnerLastEvalReason) {
+                info += `\n${theme.fg("dim", "Last evaluation:")} ${this.goalRunnerLastEvalReason}\n`;
+            }
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Markdown(info, 1, 0, this.getMarkdownThemeWithSettings()));
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(theme.fg("dim", `  /goal clear  - clear goal`), 1, 0));
+            this.ui.requestRender();
+            return false;
+        }
+        // Handle clear / stop / off / reset / cancel aliases (like Claude Code)
+        const lower = goal.toLowerCase();
+        const clearAliases = new Set(["clear", "stop", "off", "reset", "none", "cancel"]);
+        if (clearAliases.has(lower)) {
+            const prevGoal = this.session.sessionGoal;
+            if (prevGoal) {
+                this.goalRunnerEnabled = false;
+                this.goalRunnerAbortController?.abort();
+                this.goalRunnerTurnCount = 0;
+                this.goalRunnerStartTime = 0;
+                this.goalRunnerTokenSpend = 0;
+                this.goalRunnerLastEvalReason = "";
+                // Clear the goal from session and rebuild system prompt
+                this.session.clearSessionGoal();
                 this.chatContainer.addChild(new Spacer(1));
-                this.chatContainer.addChild(new Text(theme.fg("dim", `Session goal: ${currentGoal} (goal runner: ${runnerStatus})`), 1, 0));
-                this.chatContainer.addChild(new Text(theme.fg("dim", `  /goal on  - enable goal runner`), 1, 0));
-                this.chatContainer.addChild(new Text(theme.fg("dim", `  /goal off - pause goal runner`), 1, 0));
+                this.chatContainer.addChild(new Text(theme.fg("dim", `Goal cleared: "${prevGoal}"`), 1, 0));
             }
             else {
-                this.showWarning("Usage: /goal <goal description>");
+                this.showWarning("No active goal to clear.");
             }
             this.ui.requestRender();
-            return;
+            return false;
         }
-        const lower = goal.toLowerCase();
-        if (lower === "on" || lower === "off") {
-            this.goalRunnerEnabled = lower === "on";
-            if (lower === "on") {
-                this.goalRunnerRecentOutputs = [];
-            }
+        if (lower === "on") {
+            this.goalRunnerEnabled = true;
             const currentGoal = this.session.sessionGoal;
             if (currentGoal) {
-                const label = lower === "on" ? theme.fg("success", "enabled") : theme.fg("warning", "paused");
                 this.chatContainer.addChild(new Spacer(1));
-                this.chatContainer.addChild(new Text(theme.fg("dim", `Goal runner ${label} for goal: "${currentGoal}"`), 1, 0));
+                this.chatContainer.addChild(new Text(theme.fg("success", `Goal runner enabled for: "${currentGoal}"`), 1, 0));
             }
             else {
-                this.showWarning("No goal is set. Use /goal <description> to set one first.");
+                this.showWarning("No goal is set. Use /goal <condition> to set one first.");
             }
             this.ui.requestRender();
-            return;
+            return false;
         }
+        // Set new goal — like Claude Code, the goal text is submitted as the next user message
         this.session.setSessionGoal(goal);
         this.goalRunnerEnabled = true;
-        this.goalRunnerRecentOutputs = [];
+        this.goalRunnerTurnCount = 0;
+        this.goalRunnerStartTime = Date.now();
+        this.goalRunnerTokenSpend = 0;
+        this.goalRunnerLastEvalReason = "";
         this.chatContainer.addChild(new Spacer(1));
-        this.chatContainer.addChild(new Text(theme.fg("dim", `Session goal set: ${goal}`), 1, 0));
+        this.chatContainer.addChild(new Text(theme.fg("dim", `Session goal set: "${goal}" — working toward it...`), 1, 0));
         this.ui.requestRender();
+        return true;
+    }
+    formatDuration(ms) {
+        const seconds = Math.floor(ms / 1000);
+        if (seconds < 60)
+            return `${seconds}s`;
+        const minutes = Math.floor(seconds / 60);
+        const secs = seconds % 60;
+        if (minutes < 60)
+            return `${minutes}m ${secs}s`;
+        const hours = Math.floor(minutes / 60);
+        const mins = minutes % 60;
+        return `${hours}h ${mins}m ${secs}s`;
     }
     /**
-     * Goal runner continuation loop.
-     * After each turn completes, auto-prompts the agent to continue pursuing the goal.
-     * Handles errors with exponential backoff and respects user interruption.
+     * Goal runner continuation loop — Claude Code-style evaluator loop.
+     *
+     * After each turn:
+     * 1. Runs the evaluator to check if the condition is met
+     * 2. If met: shows achievement and stops
+     * 3. If not met: continues with next turn
+     *
+     * Handles errors with exponential backoff.
+     * User can interrupt with the interrupt key.
      * Survives crashes: on next startup, the persisted session goal triggers auto-resume.
      */
     async goalRunnerContinuationLoop(goal) {
-        // Abort any previous goal runner controller
         this.goalRunnerAbortController?.abort();
         this.goalRunnerAbortController = new AbortController();
         const signal = this.goalRunnerAbortController.signal;
+        let nextDirection;
         try {
             while (this.goalRunnerEnabled && this.session.sessionGoal) {
                 if (signal.aborted)
                     break;
-                // Small delay between turns so the user can see what happened
                 try {
                     await sleep(this.GOAL_RUNNER_TURN_DELAY_MS, signal);
                 }
@@ -4659,67 +4711,69 @@ export class InteractiveMode {
                 }
                 if (signal.aborted)
                     break;
-                // Skip if the agent is already streaming or compacting
-                if (this.session.isStreaming || this.session.isCompacting) {
+                if (this.session.isStreaming || this.session.isCompacting)
                     continue;
-                }
-                // Show status on first iteration
                 if (!this.goalRunnerStatusDisplayed) {
                     this.goalRunnerStatusDisplayed = true;
-                    this.showStatus(`Pursuing goal: "${goal}" (${keyText("app.interrupt")} to pause)`);
+                    this.showStatus(`Goal: "${goal}" (${keyText("app.interrupt")} to pause, /goal clear to clear)`);
                 }
                 try {
-                    await this.session.prompt(`Continue pursuing the goal: "${goal}". If you have fully completed this goal, report what was accomplished. If you cannot make further progress, explain what blocked you. Do not repeat the same status/report as previous turns — either make concrete progress or clearly state that the goal is done/blocked.`);
-                    // Successful turn completed, reset retry counter
+                    // Use evaluator's nextDirection, or fall back to generic prompt
+                    const promptText = nextDirection
+                        ? nextDirection
+                        : `Work toward the goal: "${goal}". This goal must be completed. Explore, plan, and execute. Do not stop until it is done.`;
+                    nextDirection = undefined;
+                    await this.session.prompt(promptText);
                     this.goalRunnerRetryAttempt = 0;
-                    // Auto-pause when the model keeps emitting near-duplicate content.
-                    const lastText = this.session.getLastAssistantText();
-                    if (lastText) {
-                        const normalized = normalizeGoalOutput(lastText);
-                        const prev = this.goalRunnerRecentOutputs[this.goalRunnerRecentOutputs.length - 1];
-                        if (prev && isNearDuplicateGoalOutput(prev, normalized)) {
-                            this.goalRunnerRecentOutputs.push(normalized);
-                        }
-                        else {
-                            this.goalRunnerRecentOutputs = [normalized];
-                        }
-                        // Keep a small window
-                        if (this.goalRunnerRecentOutputs.length > this.GOAL_RUNNER_MAX_DUPLICATE_STREAK) {
-                            this.goalRunnerRecentOutputs = this.goalRunnerRecentOutputs.slice(-this.GOAL_RUNNER_MAX_DUPLICATE_STREAK);
-                        }
-                        if (this.goalRunnerRecentOutputs.length >= this.GOAL_RUNNER_MAX_DUPLICATE_STREAK) {
-                            const window = this.goalRunnerRecentOutputs;
-                            let allDup = true;
-                            for (let i = 1; i < window.length; i++) {
-                                if (!isNearDuplicateGoalOutput(window[i - 1], window[i])) {
-                                    allDup = false;
-                                    break;
-                                }
-                            }
-                            if (allDup) {
+                    this.goalRunnerTurnCount++;
+                    // Track token spend from last assistant message if available
+                    const lastMsg = this.session.getLastAssistantMessage();
+                    if (lastMsg?.usage) {
+                        this.goalRunnerTokenSpend += lastMsg.usage.input + lastMsg.usage.output;
+                    }
+                    // Run evaluator to check if condition is met
+                    const model = this.session.model;
+                    if (model) {
+                        const auth = await this.session.modelRegistry.getApiKeyAndHeaders(model);
+                        if (auth.ok) {
+                            const lastText = this.session.getLastAssistantText();
+                            const evaluation = await evaluateGoalCondition(goal, lastText, model, {
+                                apiKey: auth.apiKey,
+                                headers: auth.headers,
+                                signal,
+                            });
+                            this.goalRunnerLastEvalReason = evaluation.reason;
+                            if (evaluation.met) {
                                 this.goalRunnerEnabled = false;
-                                this.goalRunnerRecentOutputs = [];
-                                this.showStatus(`Goal runner paused: model repeated similar output ${this.GOAL_RUNNER_MAX_DUPLICATE_STREAK} turns in a row. Use /goal on to resume, or refine the goal.`);
+                                const elapsed = this.formatDuration(Date.now() - this.goalRunnerStartTime);
+                                this.chatContainer.addChild(new Spacer(1));
+                                this.chatContainer.addChild(new Text(theme.fg("success", `Goal achieved! (${this.goalRunnerTurnCount} turns, ${elapsed})`), 1, 0));
+                                this.chatContainer.addChild(new Text(theme.fg("dim", `  ${evaluation.reason}`), 1, 0));
+                                this.ui.requestRender();
                                 break;
                             }
+                            // Capture next direction from evaluator
+                            nextDirection = evaluation.nextDirection;
+                            // Update status with evaluator reason
+                            this.showStatus(`Goal: "${goal}" — ${evaluation.reason} (${this.goalRunnerTurnCount} turn(s), ${keyText("app.interrupt")} to pause)`);
+                        }
+                        else {
+                            nextDirection = undefined;
+                            this.showStatus(`Goal: "${goal}" — continuing (${this.goalRunnerTurnCount} turn(s), ${keyText("app.interrupt")} to pause)`);
                         }
                     }
+                    else {
+                        nextDirection = undefined;
+                        this.showStatus(`Goal: "${goal}" — continuing (${this.goalRunnerTurnCount} turn(s), ${keyText("app.interrupt")} to pause)`);
+                    }
                 }
                 catch (error) {
+                    // Error occurred — retry indefinitely, never stop
                     this.goalRunnerRetryAttempt++;
                     const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                    if (this.goalRunnerRetryAttempt >= this.GOAL_RUNNER_MAX_RETRIES) {
-                        this.goalRunnerEnabled = false;
-                        this.showError(`Goal runner paused after ${this.GOAL_RUNNER_MAX_RETRIES} consecutive errors. ` +
-                            `Last error: ${errorMessage}. Use /goal on to resume.`);
-                        break;
-                    }
-                    // Exponential backoff
-                    const delay = this.GOAL_RUNNER_BASE_DELAY_MS * 2 ** (this.goalRunnerRetryAttempt - 1);
-                    this.showStatus(`Goal runner error, retrying in ${Math.ceil(delay / 1000)}s ` +
-                        `(${this.goalRunnerRetryAttempt}/${this.GOAL_RUNNER_MAX_RETRIES})... (${keyText("app.interrupt")} to pause)`);
+                    this.showStatus(`Goal runner error (attempt ${this.goalRunnerRetryAttempt}), retrying in ${Math.ceil(this.GOAL_RUNNER_RETRY_DELAY_MS / 1000)}s: ${errorMessage} — (${keyText("app.interrupt")} to pause)`);
                     try {
-                        await sleep(delay, signal);
+                        await sleep(this.GOAL_RUNNER_RETRY_DELAY_MS, signal);
                     }
                     catch {
                         break;