@workermill/agent 0.7.5 → 0.7.7

package/dist/config.d.ts

@@ -17,7 +17,7 @@ export interface AgentConfig {
     gitlabToken: string;
     workerImage: string;
     teamPlanningEnabled: boolean;
-    analystModel: string;
+    analystModel?: string;
 }
 export interface FileConfig {
     apiUrl: string;

package/dist/config.js

@@ -76,7 +76,7 @@ export function loadConfigFromFile() {
         gitlabToken: fc.tokens?.gitlab || "",
         workerImage,
         teamPlanningEnabled: fc.teamPlanningEnabled ?? true,
-        analystModel: fc.analystModel || "sonnet",
+        analystModel: fc.analystModel,
     };
 }
 /**
@@ -122,7 +122,7 @@ export function loadConfig() {
         gitlabToken: process.env.GITLAB_TOKEN || "",
         workerImage: process.env.WORKER_IMAGE || "workermill-worker:local",
         teamPlanningEnabled: process.env.TEAM_PLANNING_ENABLED !== "false",
-        analystModel: process.env.ANALYST_MODEL || "sonnet",
+        analystModel: process.env.ANALYST_MODEL,
     };
 }
 /**

package/dist/planner.js

@@ -103,6 +103,24 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         let stderrOutput = "";
         let charsReceived = 0;
         let toolCallCount = 0;
+        // 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
+        // flush whatever remains (including any incomplete trailing line).
+        let textBuffer = "";
+        function flushTextBuffer(final = false) {
+            if (!textBuffer)
+                return;
+            const parts = textBuffer.split("\n");
+            // Keep the incomplete trailing fragment unless this is the final flush
+            const incomplete = final ? "" : (parts.pop() || "");
+            for (const line of parts) {
+                if (line.trim()) {
+                    postLog(taskId, `${PREFIX} ${line}`, "output");
+                }
+            }
+            textBuffer = incomplete;
+        }
         // Phase detection state
         let currentPhase = "initializing";
         let firstTextSeen = false;
@@ -117,6 +135,8 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             postLog(taskId, msg);
             console.log(`${ts()} ${taskLabel} ${chalk.dim(msg)}`);
         }
+        // Flush buffered LLM text to dashboard every 1s (complete lines only)
+        const textFlushInterval = setInterval(() => flushTextBuffer(), 1_000);
         // SSE progress updates every 2s — drives PlanningTerminalBar in dashboard
         // (same cadence as local dev's progressInterval in planning-agent-local.ts)
         const sseProgressInterval = setInterval(() => {
@@ -193,6 +213,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                         // Fallback: raw API streaming format
                         fullText += event.delta.text;
                         charsReceived += event.delta.text.length;
+                        textBuffer += event.delta.text;
                         if (!firstTextSeen) {
                             firstTextSeen = true;
                             if (toolCallCount > 0 && !milestoneSent.analyzing) {
@@ -230,6 +251,8 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         const timeout = setTimeout(() => {
             clearInterval(progressInterval);
             clearInterval(sseProgressInterval);
+            clearInterval(textFlushInterval);
+            flushTextBuffer(true);
             proc.kill("SIGTERM");
             reject(new Error("Claude CLI timed out after 20 minutes"));
         }, 1_200_000);
@@ -237,6 +260,8 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             clearTimeout(timeout);
             clearInterval(progressInterval);
             clearInterval(sseProgressInterval);
+            clearInterval(textFlushInterval);
+            flushTextBuffer(true);
             // Emit final "validating" phase to dashboard
             const elapsedAtClose = Math.round((Date.now() - startTime) / 1000);
             postProgress(taskId, "validating", elapsedAtClose, "Validating plan...", charsReceived, toolCallCount);
@@ -252,6 +277,8 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             clearTimeout(timeout);
             clearInterval(progressInterval);
             clearInterval(sseProgressInterval);
+            clearInterval(textFlushInterval);
+            flushTextBuffer(true);
             reject(err);
         });
     });
@@ -603,7 +630,7 @@ export async function planTask(task, config, credentials) {
     });
     const { prompt: basePrompt, model, provider: planningProvider, maxStories: apiMaxStories } = promptResponse.data;
     const maxStories = typeof apiMaxStories === "number" ? apiMaxStories : 8;
-    const cliModel = model || "sonnet";
+    const cliModel = model;
     const provider = (planningProvider || "anthropic");
     const isAnthropicPlanning = provider === "anthropic";
     const claudePath = process.env.CLAUDE_CLI_PATH || findClaudePath() || "claude";
@@ -633,7 +660,7 @@ export async function planTask(task, config, credentials) {
             console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} No SCM token for ${scmProvider}, skipping team planning`);
         }
         if (repoPath) {
-            const analystModel = config.analystModel || "sonnet";
+            const analystModel = config.analystModel || cliModel;
             console.log(`${ts()} ${taskLabel} Analysts using model: ${chalk.yellow(analystModel)} (planner: ${chalk.yellow(cliModel)})`);
             const analysisResult = await runTeamAnalysis(task, basePrompt, claudePath, analystModel, cleanEnv, repoPath, task.id, startTime);
             if (analysisResult) {

package/dist/poller.js

@@ -89,6 +89,7 @@ async function pollOnce(config) {
 async function handlePlanningTask(task, config) {
     // Claim the task (also returns org credentials for provider API keys)
     let credentials;
+    let claimedTask;
     try {
         const claimResponse = await api.post("/api/agent/claim", {
             taskId: task.id,
@@ -98,11 +99,39 @@ async function handlePlanningTask(task, config) {
             return; // Another agent or cloud orchestrator claimed it
         }
         credentials = claimResponse.data.credentials;
+        claimedTask = claimResponse.data.task;
     }
     catch {
         return;
     }
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
+    // Check if this is a retry with an existing plan (resume scenario).
+    // The API preserves planJson/executionPlanV2 on retry when stories exist,
+    // so we can skip planning entirely and transition straight to queued.
+    const isRetryWithPlan = claimedTask &&
+        (claimedTask.retryCount ?? 0) > 0 &&
+        claimedTask.executionPlanV2 != null;
+    if (isRetryWithPlan) {
+        console.log();
+        console.log(`${ts()} ${chalk.magenta("◆ RESUME")} ${taskLabel} ${task.summary.substring(0, 60)}`);
+        console.log(`${ts()} ${taskLabel} Retry #${claimedTask.retryCount} with existing plan — skipping planning`);
+        planningInProgress.add(task.id);
+        // Tell the API to resume with the existing plan (planning → queued)
+        try {
+            await api.post("/api/agent/resume-plan", {
+                taskId: task.id,
+                agentId: config.agentId,
+            });
+            console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Resumed with existing plan → ${chalk.green("queued")}`);
+        }
+        catch (err) {
+            const error = err;
+            const detail = error.response?.data?.error || error.message || String(err);
+            console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Resume failed: ${detail}`);
+        }
+        planningInProgress.delete(task.id);
+        return;
+    }
     console.log();
     console.log(`${ts()} ${chalk.magenta("◆ PLANNING")} ${taskLabel} ${task.summary.substring(0, 60)}`);
     planningInProgress.add(task.id);

package/dist/spawner.js

@@ -182,9 +182,9 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         // Target repository
         TARGET_REPO: task.githubRepo || "",
         GITHUB_REPO: task.githubRepo || "",
-        // Worker model (CLAUDE_MODEL is legacy compat for manager entrypoint)
-        WORKER_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || "sonnet"),
-        CLAUDE_MODEL: task.workerProvider === "anthropic" ? (task.workerModel || "sonnet") : "sonnet",
+        // Worker model — comes from task or org settings, no hardcoded fallbacks
+        WORKER_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || ""),
+        CLAUDE_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || ""),
         // Jira credentials (from org Secrets Manager via /api/agent/claim)
         JIRA_BASE_URL: credentials?.jiraBaseUrl || "",
         JIRA_EMAIL: credentials?.jiraEmail || "",

package/package.json

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