@workermill/agent 0.7.13 → 0.7.15

package/dist/plan-validator.d.ts

@@ -39,7 +39,7 @@ export interface CriticResult {
         suggestedChanges?: string[];
     }>;
 }
-declare const AUTO_APPROVAL_THRESHOLD = 85;
+declare const AUTO_APPROVAL_THRESHOLD = 80;
 /**
  * Parse execution plan JSON from raw Claude CLI output.
  * Mirrors server-side parseExecutionPlan() in planning-agent-local.ts.

package/dist/plan-validator.js

@@ -16,7 +16,7 @@ import { generateText } from "./providers.js";
 // CONSTANTS
 // ============================================================================
 const MAX_TARGET_FILES = 5;
-const AUTO_APPROVAL_THRESHOLD = 85;
+const AUTO_APPROVAL_THRESHOLD = 80;
 // ============================================================================
 // PLAN PARSING
 // ============================================================================

package/dist/planner.d.ts

@@ -31,8 +31,9 @@ export interface PlanningTask {
  *   2. Run Claude CLI to generate plan
  *   3. Parse plan, apply file cap (max 5 files per story)
  *   4. Run critic validation via Claude CLI
- *   5. If critic approves (score >= 85): post validated plan to API
+ *   5. If critic approves (score >= 80): post validated plan to API
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
- *   7. After MAX_ITERATIONS without approval: fail the task
+ *   7. After MAX_ITERATIONS without approval: post best plan if score >= 50 (fallback)
+ *   8. If no plan scored >= 50: fail the task
  */
 export declare function planTask(task: PlanningTask, config: AgentConfig, credentials?: ClaimCredentials): Promise<boolean>;

package/dist/planner.js

@@ -15,7 +15,6 @@
  * sees the same planning progress as cloud mode.
  */
 import chalk from "chalk";
-import ora from "ora";
 import { spawn, execSync } from "child_process";
 import { findClaudePath } from "./config.js";
 import { api } from "./api.js";
@@ -104,23 +103,6 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         let stderrOutput = "";
         let charsReceived = 0;
         let toolCallCount = 0;
-        // Live spinner — shows elapsed time, phase, and chars generated
-        const spinner = ora({
-            text: `${taskLabel} Initializing planner...`,
-            prefixText: "",
-            spinner: "dots",
-        }).start();
-        function updateSpinner() {
-            const elapsed = Math.round((Date.now() - startTime) / 1000);
-            const phaseIcon = currentPhase === "reading_repo" ? "📂" :
-                currentPhase === "analyzing" ? "🔍" :
-                    currentPhase === "generating_plan" ? "📝" :
-                        currentPhase === "validating" ? "✅" : "⏳";
-            const stats = chalk.dim(`${formatElapsed(elapsed)} · ${charsReceived} chars · ${toolCallCount} tools`);
-            spinner.text = `${taskLabel} ${phaseIcon} ${phaseLabel(currentPhase, elapsed)}  ${stats}`;
-        }
-        // Update spinner every 500ms for smooth elapsed time display
-        const spinnerInterval = setInterval(updateSpinner, 500);
         // Buffered text streaming — flush complete lines to dashboard every 1s.
         // LLM deltas are tiny fragments; we accumulate until we see '\n', then
         // a 1s interval flushes all complete lines as log entries.  On exit we
@@ -136,10 +118,8 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                 if (line.trim()) {
                     postLog(taskId, `${PREFIX} ${line}`, "output");
                     // Echo planner thoughts to local terminal
-                    spinner.stop();
                     const truncated = line.trim().length > 160 ? line.trim().substring(0, 160) + "…" : line.trim();
                     console.log(`${ts()} ${taskLabel} ${chalk.dim("💭")} ${chalk.dim(truncated)}`);
-                    spinner.start();
                 }
             }
             textBuffer = incomplete;
@@ -156,10 +136,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             const elapsed = Math.round((Date.now() - startTime) / 1000);
             const msg = phaseLabel(newPhase, elapsed);
             postLog(taskId, msg);
-            spinner.stop();
             console.log(`${ts()} ${taskLabel} ${chalk.dim(msg)}`);
-            spinner.start();
-            updateSpinner();
         }
         // Flush buffered LLM text to dashboard every 1s (complete lines only)
         const textFlushInterval = setInterval(() => flushTextBuffer(), 1_000);
@@ -185,9 +162,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                 lastProgressLogAt = elapsed;
                 const msg = `${PREFIX} Planning in progress — analyzing requirements and decomposing into steps (${formatElapsed(elapsed)} elapsed)`;
                 postLog(taskId, msg);
-                spinner.stop();
                 console.log(`${ts()} ${taskLabel} ${chalk.dim(msg)}`);
-                spinner.start();
             }
         }, 5_000);
         // Parse streaming JSON lines from Claude CLI
@@ -280,9 +255,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             clearInterval(progressInterval);
             clearInterval(sseProgressInterval);
             clearInterval(textFlushInterval);
-            clearInterval(spinnerInterval);
             flushTextBuffer(true);
-            spinner.stop();
         }
         const timeout = setTimeout(() => {
             cleanupAll();
@@ -407,23 +380,12 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
         let toolCalls = 0;
         let timedOut = false;
         const startMs = Date.now();
-        // Live spinner for this analyst
-        const analystSpinner = ora({
-            text: `${label} Starting (${model})...`,
-            spinner: "dots",
-        }).start();
-        const analystSpinnerInterval = setInterval(() => {
-            const elapsed = Math.round((Date.now() - startMs) / 1000);
-            analystSpinner.text = `${label} ${chalk.dim(`${formatElapsed(elapsed)} · ${toolCalls} tools · ${fullText.length} chars`)}`;
-        }, 500);
         proc.stderr.on("data", (chunk) => {
             const text = chunk.toString();
             stderrOutput += text;
             // Show stderr in real-time so we can see what's happening
             for (const line of text.split("\n").filter((l) => l.trim())) {
-                analystSpinner.stop();
                 console.log(`${ts()} ${label} ${chalk.red("stderr:")} ${line.trim()}`);
-                analystSpinner.start();
             }
         });
         proc.stdout.on("data", (data) => {
@@ -446,11 +408,9 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
                                     // Log analyst reasoning (first line, truncated)
                                     const thought = block.text.trim().split("\n")[0].substring(0, 120);
                                     if (thought) {
-                                        analystSpinner.stop();
                                         console.log(`${ts()} ${label} ${chalk.dim("💭")} ${chalk.dim(thought)}`);
                                         if (taskId)
                                             postLog(taskId, `${PREFIX} [${name}] 💭 ${thought}`);
-                                        analystSpinner.start();
                                     }
                                 }
                                 else if (block.type === "tool_use") {
@@ -459,11 +419,9 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
                                     // Show tool name + input preview (file path, pattern, etc.)
                                     const inputStr = block.input ? JSON.stringify(block.input) : "";
                                     const inputPreview = inputStr.length > 80 ? inputStr.substring(0, 80) + "…" : inputStr;
-                                    analystSpinner.stop();
                                     console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)}${inputPreview ? chalk.dim(` ${inputPreview}`) : ""}`);
                                     if (taskId)
                                         postLog(taskId, `${PREFIX} [${name}] Tool: ${toolName} ${inputPreview}`);
-                                    analystSpinner.start();
                                 }
                             }
                         }
@@ -478,11 +436,9 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
                     else if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
                         toolCalls++;
                         const toolName = event.content_block?.name || "unknown";
-                        analystSpinner.stop();
                         console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)}`);
                         if (taskId)
                             postLog(taskId, `${PREFIX} [${name}] Tool: ${toolName}`);
-                        analystSpinner.start();
                     }
                     else if (event.type === "result" && event.result) {
                         resultText =
@@ -496,8 +452,6 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
         });
         const timeout = setTimeout(() => {
             timedOut = true;
-            clearInterval(analystSpinnerInterval);
-            analystSpinner.stop();
             proc.kill("SIGTERM");
             const elapsed = Math.round((Date.now() - startMs) / 1000);
             console.log(`${ts()} ${label} ${chalk.yellow("⚠ Timed out")} after ${formatElapsed(elapsed)} (${toolCalls} tool calls, ${fullText.length} chars)`);
@@ -507,8 +461,6 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
         }, timeoutMs);
         proc.on("exit", (code) => {
             clearTimeout(timeout);
-            clearInterval(analystSpinnerInterval);
-            analystSpinner.stop();
             const elapsed = Math.round((Date.now() - startMs) / 1000);
             if (timedOut)
                 return; // already resolved
@@ -532,8 +484,6 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
         });
         proc.on("error", (err) => {
             clearTimeout(timeout);
-            clearInterval(analystSpinnerInterval);
-            analystSpinner.stop();
             console.log(`${ts()} ${label} ${chalk.red("✗ Spawn failed:")} ${err.message}`);
             resolve("");
         });
@@ -736,9 +686,10 @@ async function runTeamAnalysis(task, basePrompt, claudePath, model, env, repoPat
  *   2. Run Claude CLI to generate plan
  *   3. Parse plan, apply file cap (max 5 files per story)
  *   4. Run critic validation via Claude CLI
- *   5. If critic approves (score >= 85): post validated plan to API
+ *   5. If critic approves (score >= 80): post validated plan to API
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
- *   7. After MAX_ITERATIONS without approval: fail the task
+ *   7. After MAX_ITERATIONS without approval: post best plan if score >= 50 (fallback)
+ *   8. If no plan scored >= 50: fail the task
  */
 export async function planTask(task, config, credentials) {
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
@@ -972,7 +923,32 @@ export async function planTask(task, config, credentials) {
                 }
             }
         }
-        // All iterations exhausted — fail
+        // All iterations exhausted — try best-plan fallback before failing.
+        // If we have a plan that scored >= BEST_PLAN_FALLBACK_THRESHOLD, post it
+        // with a warning instead of discarding it entirely.
+        const BEST_PLAN_FALLBACK_THRESHOLD = 50;
+        if (bestPlan && bestScore >= BEST_PLAN_FALLBACK_THRESHOLD) {
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            const msg = `${PREFIX} Best-plan fallback: posting plan with score ${bestScore}/100 (below ${AUTO_APPROVAL_THRESHOLD} threshold, above ${BEST_PLAN_FALLBACK_THRESHOLD} minimum)`;
+            console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
+            await postLog(task.id, msg);
+            const planningDurationMs = Date.now() - startTime;
+            return await postValidatedPlan(task.id, bestPlan, config.agentId, taskLabel, elapsed, bestScore, [`Best-plan fallback: critic rejected after ${MAX_ITERATIONS} iterations`], criticHistory, totalFileCapTruncations, planningDurationMs, MAX_ITERATIONS);
+        }
+        // No usable plan — report failure to server so the task doesn't
+        // stay in "planning" status forever (which causes an infinite retry loop).
+        try {
+            await api.post("/api/agent/plan-failed", {
+                taskId: task.id,
+                agentId: config.agentId,
+                reason: `Critic rejected after ${MAX_ITERATIONS} iterations (best score: ${bestScore}/100, threshold: ${AUTO_APPROVAL_THRESHOLD}, fallback minimum: ${BEST_PLAN_FALLBACK_THRESHOLD})`,
+                criticHistory,
+            });
+        }
+        catch {
+            // Best-effort — if the endpoint doesn't exist yet, the task will still
+            // be picked up again, but at least we tried.
+        }
         return false;
     }
     finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workermill/agent",
-  "version": "0.7.13",
+  "version": "0.7.15",
   "description": "WorkerMill Remote Agent - Run AI workers locally with your Claude Max subscription",
   "type": "module",
   "main": "./dist/index.js",