@workermill/agent 0.7.18 → 0.7.20

package/dist/plan-validator.d.ts

@@ -90,7 +90,7 @@ export declare function parseCriticResponse(text: string): CriticResult;
  * Run the critic via Claude CLI (lightweight — no tools, just reasoning).
  * Returns the raw text output.
  */
-export declare function runCriticCli(claudePath: string, model: string, prompt: string, env: Record<string, string | undefined>): Promise<string>;
+export declare function runCriticCli(claudePath: string, model: string, prompt: string, env: Record<string, string | undefined>, taskId?: string): Promise<string>;
 /**
  * Format critic feedback for appending to the planner prompt on re-run.
  */
@@ -100,5 +100,5 @@ export declare function formatCriticFeedback(critic: CriticResult): string;
  * Routes to Claude CLI (Anthropic) or HTTP API (other providers).
  * Returns the critic result, or null if critic fails (non-blocking).
  */
-export declare function runCriticValidation(claudePath: string, model: string, prd: string, plan: ExecutionPlan, env: Record<string, string | undefined>, taskLabel: string, provider?: AIProvider, providerApiKey?: string): Promise<CriticResult | null>;
+export declare function runCriticValidation(claudePath: string, model: string, prd: string, plan: ExecutionPlan, env: Record<string, string | undefined>, taskLabel: string, provider?: AIProvider, providerApiKey?: string, taskId?: string): Promise<CriticResult | null>;
 export { AUTO_APPROVAL_THRESHOLD };

package/dist/plan-validator.js

@@ -12,6 +12,7 @@
 import { spawn } from "child_process";
 import chalk from "chalk";
 import { generateText } from "./providers.js";
+import { api } from "./api.js";
 // ============================================================================
 // CONSTANTS
 // ============================================================================
@@ -277,7 +278,7 @@ export function parseCriticResponse(text) {
  * Run the critic via Claude CLI (lightweight — no tools, just reasoning).
  * Returns the raw text output.
  */
-export function runCriticCli(claudePath, model, prompt, env) {
+export function runCriticCli(claudePath, model, prompt, env, taskId) {
     return new Promise((resolve, reject) => {
         const proc = spawn(claudePath, [
             "--print",
@@ -294,7 +295,21 @@ export function runCriticCli(claudePath, model, prompt, env) {
         let stdout = "";
         let stderr = "";
         proc.stdout.on("data", (data) => {
-            stdout += data.toString();
+            const chunk = data.toString();
+            stdout += chunk;
+            // Stream critic reasoning to dashboard in real-time
+            const lines = chunk.split("\n").filter((l) => l.trim());
+            for (const line of lines) {
+                const trimmed = line.trim().length > 200
+                    ? line.trim().substring(0, 200) + "…"
+                    : line.trim();
+                if (trimmed) {
+                    if (taskId) {
+                        postLog(taskId, `${PREFIX} [critic] ${trimmed}`, "output");
+                    }
+                    console.log(`${ts()} ${chalk.dim("🔍")} ${chalk.dim(trimmed)}`);
+                }
+            }
         });
         proc.stderr.on("data", (data) => {
             stderr += data.toString();
@@ -358,23 +373,44 @@ export function formatCriticFeedback(critic) {
     lines.push("**You MUST address ALL feedback above.** Each story must target at most 5 files.", "Stories MUST NOT overlap on targetFiles. Generate a revised plan.");
     return lines.join("\n");
 }
+/** Consistent prefix matching planner dashboard format */
+const PREFIX = "[🗺️ planning_agent 🤖]";
 /** Timestamp prefix for console logs */
 function ts() {
     return chalk.dim(new Date().toLocaleTimeString());
 }
+/**
+ * Post a log message to the cloud dashboard for real-time visibility.
+ */
+async function postLog(taskId, message, type = "system", severity = "info") {
+    try {
+        await api.post("/api/control-center/logs", {
+            taskId,
+            type,
+            message,
+            severity,
+        });
+    }
+    catch {
+        // Fire and forget — don't block critic on log failures
+    }
+}
 /**
  * Run critic validation on a parsed plan.
  * Routes to Claude CLI (Anthropic) or HTTP API (other providers).
  * Returns the critic result, or null if critic fails (non-blocking).
  */
-export async function runCriticValidation(claudePath, model, prd, plan, env, taskLabel, provider, providerApiKey) {
+export async function runCriticValidation(claudePath, model, prd, plan, env, taskLabel, provider, providerApiKey, taskId) {
     const criticPrompt = buildCriticPrompt(prd, plan);
     const effectiveProvider = provider || "anthropic";
     console.log(`${ts()} ${taskLabel} ${chalk.dim(`Running critic validation (${effectiveProvider})...`)}`);
+    if (taskId) {
+        postLog(taskId, `${PREFIX} Running critic validation (${effectiveProvider})...`);
+    }
     try {
         let rawCriticOutput;
         if (effectiveProvider === "anthropic") {
-            rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env);
+            rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env, taskId);
         }
         else {
             if (!providerApiKey) {

package/dist/planner.js

@@ -70,20 +70,50 @@ const MAX_ITERATIONS = 3;
 function ts() {
     return chalk.dim(new Date().toLocaleTimeString());
 }
+/**
+ * Log queue — sends entries sequentially instead of N concurrent POSTs.
+ * During planning, flushTextBuffer() can fire 15-30 postLog() calls in a burst.
+ * Without queuing, those concurrent POSTs saturate the API's DB connection pool
+ * (max 10), causing poll timeouts, transient 401s, and multi-second stalls.
+ */
+const logQueue = [];
+let logDrainPromise = null;
+async function drainLogQueue() {
+    while (logQueue.length > 0) {
+        const entry = logQueue.shift();
+        try {
+            await api.post("/api/control-center/logs", entry, { timeout: 5_000 });
+        }
+        catch {
+            // Best-effort — drop on failure
+        }
+    }
+}
 /**
  * Post a log message to the cloud dashboard for real-time visibility.
+ * Entries are queued and drained sequentially (max 1 in-flight POST).
  */
 async function postLog(taskId, message, type = "system", severity = "info") {
-    try {
-        await api.post("/api/control-center/logs", {
-            taskId,
-            type,
-            message,
-            severity,
+    if (logQueue.length >= 200)
+        logQueue.shift(); // drop oldest
+    logQueue.push({ taskId, message, type, severity });
+    if (!logDrainPromise) {
+        logDrainPromise = drainLogQueue().finally(() => {
+            logDrainPromise = null;
         });
     }
-    catch {
-        // Fire and forget — don't block planning on log failures
+}
+/**
+ * Flush remaining log entries (call before cleanup).
+ */
+async function flushLogQueue() {
+    if (logDrainPromise)
+        await logDrainPromise;
+    if (logQueue.length > 0) {
+        logDrainPromise = drainLogQueue().finally(() => {
+            logDrainPromise = null;
+        });
+        await logDrainPromise;
     }
 }
 /**
@@ -238,6 +268,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime, disable
                                 if (block.type === "text" && block.text) {
                                     fullText += block.text;
                                     charsReceived += block.text.length;
+                                    textBuffer += block.text;
                                     if (!firstTextSeen) {
                                         firstTextSeen = true;
                                         if (toolCallCount > 0 && !milestoneSent.analyzing) {
@@ -263,6 +294,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime, disable
                         else if (typeof content === "string" && content) {
                             fullText += content;
                             charsReceived += content.length;
+                            textBuffer += content;
                         }
                     }
                     else if (event.type === "content_block_delta" && event.delta?.text) {
@@ -919,7 +951,7 @@ export async function planTask(task, config, credentials) {
             console.log(`${ts()} ${taskLabel} Plan: ${chalk.bold(plan.stories.length)} stories (max ${maxStories})`);
             await postLog(task.id, `${PREFIX} Plan generated: ${plan.stories.length} stories (${formatElapsed(elapsed)}). Running critic validation...`);
             // 2d. Run critic validation
-            const criticResult = await runCriticValidation(claudePath, cliModel, prd, plan, cleanEnv, taskLabel, provider, providerApiKey);
+            const criticResult = await runCriticValidation(claudePath, cliModel, prd, plan, cleanEnv, taskLabel, provider, providerApiKey, task.id);
             // Track best plan across iterations
             if (criticResult && criticResult.score > bestScore) {
                 bestPlan = plan;
@@ -1036,6 +1068,8 @@ export async function planTask(task, config, credentials) {
         return false;
     }
     finally {
+        // Drain any remaining log entries before cleanup
+        await flushLogQueue();
         // Cleanup temp clone
         if (repoPath) {
             try {

package/dist/poller.js

@@ -75,12 +75,17 @@ async function pollOnce(config) {
     }
     catch (error) {
         const err = error;
+        const busy = planningInProgress.size > 0 || getActiveCount() > 0 || managerInProgress.size > 0;
         if (err.response?.status === 401) {
-            console.error(`${ts()} ${chalk.red("✗")} Authentication failed. Check your API key.`);
+            if (!busy) {
+                console.error(`${ts()} ${chalk.red("✗")} Authentication failed. Check your API key.`);
+            }
+            // Silent when busy — transient DB pool exhaustion on server
         }
-        else {
-            console.error(`${ts()} ${chalk.red("✗")} Poll error: ${err.message || String(error)}`);
+        else if (!busy) {
+            console.warn(`${ts()} ${chalk.yellow("⚠")} Poll error: ${err.message || String(error)}`);
         }
+        // Silent when busy — expected during heavy planning/execution
     }
 }
 /**
@@ -181,7 +186,7 @@ async function handleQueuedTask(task, config) {
     }
     catch (err) {
         const taskLabel = chalk.cyan(task.id.slice(0, 8));
-        console.error(`${ts()} ${chalk.red("✗")} Failed to report started for ${taskLabel}`);
+        console.warn(`${ts()} ${chalk.yellow("⚠")} Failed to report started for ${taskLabel}`);
     }
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
     console.log();

package/package.json

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