@workermill/agent 0.4.3 → 0.4.6

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 = 75;
 /**
  * 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 = 75;
 // ============================================================================
 // PLAN PARSING
 // ============================================================================

package/dist/planner.js

@@ -297,8 +297,10 @@ async function cloneTargetRepo(repo, token, scmProvider, taskId) {
  * Run an analyst agent via Claude CLI with tool access to the cloned repo.
  * Returns the analyst's report text, or an empty string on failure.
  */
-function runAnalyst(claudePath, model, prompt, repoPath, env, timeoutMs = 120_000) {
+function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs = 900_000) {
+    const label = chalk.blue(`[${name}]`);
     return new Promise((resolve) => {
+        console.log(`${ts()} ${label} Starting (${chalk.dim(model)})...`);
         const proc = spawn(claudePath, [
             "--print",
             "--verbose",
@@ -310,15 +312,23 @@ function runAnalyst(claudePath, model, prompt, repoPath, env, timeoutMs = 120_00
             env,
             stdio: ["pipe", "pipe", "pipe"],
         });
-        // Write prompt via stdin (same as runClaudeCli — not via -p arg)
+        // Write prompt via stdin (same as runClaudeCli)
         proc.stdin.write(prompt);
         proc.stdin.end();
         let resultText = "";
         let fullText = "";
         let stderrOutput = "";
         let lineBuffer = "";
+        let toolCalls = 0;
+        let timedOut = false;
+        const startMs = Date.now();
         proc.stderr.on("data", (chunk) => {
-            stderrOutput += chunk.toString();
+            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())) {
+                console.log(`${ts()} ${label} ${chalk.red("stderr:")} ${line.trim()}`);
+            }
         });
         proc.stdout.on("data", (data) => {
             lineBuffer += data.toString();
@@ -333,6 +343,11 @@ function runAnalyst(claudePath, model, prompt, repoPath, env, timeoutMs = 120_00
                     if (event.type === "content_block_delta" && event.delta?.text) {
                         fullText += event.delta.text;
                     }
+                    else if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
+                        toolCalls++;
+                        const toolName = event.content_block?.name || "unknown";
+                        console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)} (${toolCalls} total)`);
+                    }
                     else if (event.type === "result" && event.result) {
                         resultText =
                             typeof event.result === "string" ? event.result : "";
@@ -344,19 +359,32 @@ function runAnalyst(claudePath, model, prompt, repoPath, env, timeoutMs = 120_00
             }
         });
         const timeout = setTimeout(() => {
+            timedOut = true;
             proc.kill("SIGTERM");
+            const elapsed = Math.round((Date.now() - startMs) / 1000);
+            console.log(`${ts()} ${label} ${chalk.yellow("⚠ Timed out")} after ${elapsed}s (${toolCalls} tool calls, ${fullText.length} chars)`);
             resolve(resultText || fullText || "");
         }, timeoutMs);
         proc.on("exit", (code) => {
             clearTimeout(timeout);
-            if (code !== 0 && stderrOutput) {
-                console.error(`${chalk.yellow("⚠")} Analyst exited with code ${code}: ${stderrOutput.substring(0, 200)}`);
+            const elapsed = Math.round((Date.now() - startMs) / 1000);
+            if (timedOut)
+                return; // already resolved
+            const output = resultText || fullText || "";
+            if (code === 0 && output.length > 0) {
+                console.log(`${ts()} ${label} ${chalk.green("✓ Done")} in ${elapsed}s (${toolCalls} tool calls, ${output.length} chars)`);
             }
-            resolve(resultText || fullText || "");
+            else if (code !== 0) {
+                console.log(`${ts()} ${label} ${chalk.red(`✗ Exited ${code}`)} after ${elapsed}s — ${stderrOutput.substring(0, 150) || "no stderr"}`);
+            }
+            else {
+                console.log(`${ts()} ${label} ${chalk.yellow("⚠ Empty output")} after ${elapsed}s (${toolCalls} tool calls)`);
+            }
+            resolve(output);
         });
         proc.on("error", (err) => {
             clearTimeout(timeout);
-            console.error(`${chalk.yellow("⚠")} Analyst spawn error: ${err.message}`);
+            console.log(`${ts()} ${label} ${chalk.red("✗ Spawn failed:")} ${err.message}`);
             resolve("");
         });
     });
@@ -411,19 +439,44 @@ async function runTeamPlanning(task, basePrompt, claudePath, model, env, repoPat
     await postLog(taskId, `${PREFIX} Team planning: running codebase, requirements, and risk analysts in parallel...`);
     await postProgress(taskId, "reading_repo", Math.round((Date.now() - startTime) / 1000), "Running parallel analysis agents...", 0, 0);
     const analysisModel = model.includes("opus") ? "sonnet" : model;
-    const [codebaseResult, requirementsResult, riskResult] = await Promise.allSettled([
-        runAnalyst(claudePath, analysisModel, CODEBASE_ANALYST_PROMPT, repoPath, env),
-        runAnalyst(claudePath, analysisModel, makeRequirementsAnalystPrompt(task), repoPath, env),
-        runAnalyst(claudePath, analysisModel, makeRiskAssessorPrompt(task), repoPath, env),
-    ]);
-    const codebaseReport = codebaseResult.status === "fulfilled" ? codebaseResult.value : "";
-    const requirementsReport = requirementsResult.status === "fulfilled" ? requirementsResult.value : "";
-    const riskReport = riskResult.status === "fulfilled" ? riskResult.value : "";
-    const successCount = [codebaseReport, requirementsReport, riskReport].filter((r) => r.length > 0).length;
-    const analysisElapsed = Math.round((Date.now() - startTime) / 1000);
-    console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Analysis complete: ${successCount}/3 reports (${analysisElapsed}s)`);
-    await postLog(taskId, `${PREFIX} Team analysis complete: ${successCount}/3 reports in ${formatElapsed(analysisElapsed)}. Synthesizing plan...`);
-    await postProgress(taskId, "analyzing", analysisElapsed, "Synthesizing analysis reports...", 0, 0);
+    const MAX_TEAM_RETRIES = 3;
+    let codebaseReport = "";
+    let requirementsReport = "";
+    let riskReport = "";
+    for (let attempt = 1; attempt <= MAX_TEAM_RETRIES; attempt++) {
+        if (attempt > 1) {
+            console.log(`${ts()} ${taskLabel} ${chalk.magenta("◆ Team planning")} — retry ${attempt}/${MAX_TEAM_RETRIES}...`);
+            await postLog(taskId, `${PREFIX} Team analysis retry ${attempt}/${MAX_TEAM_RETRIES}...`);
+        }
+        const [codebaseResult, requirementsResult, riskResult] = await Promise.allSettled([
+            codebaseReport ? Promise.resolve(codebaseReport) : runAnalyst("Codebase", claudePath, analysisModel, CODEBASE_ANALYST_PROMPT, repoPath, env),
+            requirementsReport ? Promise.resolve(requirementsReport) : runAnalyst("Requirements", claudePath, analysisModel, makeRequirementsAnalystPrompt(task), repoPath, env),
+            riskReport ? Promise.resolve(riskReport) : runAnalyst("Risk", claudePath, analysisModel, makeRiskAssessorPrompt(task), repoPath, env),
+        ]);
+        if (!codebaseReport && codebaseResult.status === "fulfilled") {
+            codebaseReport = codebaseResult.value;
+        }
+        if (!requirementsReport && requirementsResult.status === "fulfilled") {
+            requirementsReport = requirementsResult.value;
+        }
+        if (!riskReport && riskResult.status === "fulfilled") {
+            riskReport = riskResult.value;
+        }
+        const successCount = [codebaseReport, requirementsReport, riskReport].filter((r) => r.length > 0).length;
+        const analysisElapsed = Math.round((Date.now() - startTime) / 1000);
+        console.log(`${ts()} ${taskLabel} Analysis attempt ${attempt}: ${successCount}/3 reports (${analysisElapsed}s)`);
+        if (successCount > 0) {
+            console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Analysis complete: ${successCount}/3 reports (${analysisElapsed}s)`);
+            await postLog(taskId, `${PREFIX} Team analysis complete: ${successCount}/3 reports in ${formatElapsed(analysisElapsed)}. Synthesizing plan...`);
+            await postProgress(taskId, "analyzing", analysisElapsed, "Synthesizing analysis reports...", 0, 0);
+            break;
+        }
+        if (attempt === MAX_TEAM_RETRIES) {
+            console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} All analysts failed after ${MAX_TEAM_RETRIES} attempts, falling back to single-agent planning`);
+            await postLog(taskId, `${PREFIX} All analysis agents failed after ${MAX_TEAM_RETRIES} attempts — falling back to single-agent planning`);
+            return runClaudeCli(claudePath, model, basePrompt, env, taskId, startTime);
+        }
+    }
     // Build enhanced prompt with analysis reports
     const sections = [];
     if (codebaseReport) {
@@ -435,12 +488,6 @@ async function runTeamPlanning(task, basePrompt, claudePath, model, env, repoPat
     if (riskReport) {
         sections.push(`## Risk Assessment\n\n${riskReport}`);
     }
-    if (sections.length === 0) {
-        // All analysts failed — fall through to regular planning
-        console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} All analysts failed, falling back to single-agent planning`);
-        await postLog(taskId, `${PREFIX} All analysis agents failed — falling back to single-agent planning`);
-        return runClaudeCli(claudePath, model, basePrompt, env, taskId, startTime);
-    }
     const enhancedPrompt = basePrompt +
         "\n\n" +
         sections.join("\n\n") +
@@ -520,7 +567,7 @@ export async function planTask(task, config, credentials) {
             // 2a. Generate plan via Claude CLI (Anthropic) or HTTP API (other providers)
             let rawOutput;
             try {
-                if (isAnthropicPlanning && config.teamPlanningEnabled && repoPath && iteration === 1) {
+                if (isAnthropicPlanning && config.teamPlanningEnabled && repoPath) {
                     rawOutput = await runTeamPlanning(task, currentPrompt, claudePath, cliModel, cleanEnv, repoPath, task.id, startTime);
                 }
                 else if (isAnthropicPlanning) {

package/package.json

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