@workermill/agent 0.7.0 → 0.7.2

package/dist/commands/start.js

@@ -105,9 +105,23 @@ export async function startCommand(options) {
         const cleanup = await startAgent(config);
         // Write PID file for status command
         writeFileSync(getPidFile(), String(process.pid), "utf-8");
-        // Graceful shutdown
+        // Graceful shutdown with force-exit safety net
+        let shuttingDown = false;
         const shutdown = async () => {
+            if (shuttingDown) {
+                // Double Ctrl+C → force exit immediately
+                console.log(chalk.red("\n  Force exit."));
+                process.exit(1);
+            }
+            shuttingDown = true;
+            // Force exit after 10s if cleanup hangs
+            const forceTimer = setTimeout(() => {
+                console.log(chalk.red("\n  Cleanup timed out. Force exit."));
+                process.exit(1);
+            }, 10_000);
+            forceTimer.unref(); // Don't keep process alive just for this timer
             await cleanup();
+            clearTimeout(forceTimer);
             try {
                 unlinkSync(getPidFile());
             }

package/dist/index.js

@@ -6,7 +6,7 @@
  */
 import chalk from "chalk";
 import { initApi, api } from "./api.js";
-import { startPolling, startHeartbeat } from "./poller.js";
+import { startPolling, startHeartbeat, stopPolling } from "./poller.js";
 import { stopAll } from "./spawner.js";
 import { AGENT_VERSION } from "./version.js";
 import { selfUpdate, restartAgent } from "./updater.js";
@@ -82,6 +82,8 @@ export async function startAgent(config) {
     return async () => {
         console.log();
         console.log(chalk.dim("  Shutting down..."));
+        // Stop poll/heartbeat loops first so nothing re-fires during cleanup
+        stopPolling();
         try {
             await api.post("/api/agent/deregister", { agentId: config.agentId });
         }

package/dist/planner.js

@@ -154,10 +154,45 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                     continue;
                 try {
                     const event = JSON.parse(trimmed);
-                    if (event.type === "content_block_delta" && event.delta?.text) {
+                    // Claude CLI stream-json wraps content in assistant message events
+                    if (event.type === "assistant" && event.message?.content) {
+                        const content = event.message.content;
+                        if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block.type === "text" && block.text) {
+                                    fullText += block.text;
+                                    charsReceived += block.text.length;
+                                    if (!firstTextSeen) {
+                                        firstTextSeen = true;
+                                        if (toolCallCount > 0 && !milestoneSent.analyzing) {
+                                            transitionPhase("analyzing");
+                                            milestoneSent.analyzing = true;
+                                        }
+                                    }
+                                    if (charsReceived > 500 && !milestoneSent.generating) {
+                                        transitionPhase("generating_plan");
+                                        milestoneSent.generating = true;
+                                        lastProgressLogAt = Math.round((Date.now() - startTime) / 1000);
+                                    }
+                                }
+                                else if (block.type === "tool_use") {
+                                    toolCallCount++;
+                                    if (!milestoneSent.reading) {
+                                        transitionPhase("reading_repo");
+                                        milestoneSent.reading = true;
+                                    }
+                                }
+                            }
+                        }
+                        else if (typeof content === "string" && content) {
+                            fullText += content;
+                            charsReceived += content.length;
+                        }
+                    }
+                    else if (event.type === "content_block_delta" && event.delta?.text) {
+                        // Fallback: raw API streaming format
                         fullText += event.delta.text;
                         charsReceived += event.delta.text.length;
-                        // Phase: first text after tool calls → analyzing
                         if (!firstTextSeen) {
                             firstTextSeen = true;
                             if (toolCallCount > 0 && !milestoneSent.analyzing) {
@@ -165,7 +200,6 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                                 milestoneSent.analyzing = true;
                             }
                         }
-                        // Phase: substantial text → generating_plan
                         if (charsReceived > 500 && !milestoneSent.generating) {
                             transitionPhase("generating_plan");
                             milestoneSent.generating = true;
@@ -179,13 +213,6 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                             milestoneSent.reading = true;
                         }
                     }
-                    else if (event.type === "assistant" && event.message?.content) {
-                        const text = typeof event.message.content === "string" ? event.message.content : "";
-                        if (text) {
-                            fullText += text;
-                            charsReceived += text.length;
-                        }
-                    }
                     else if (event.type === "result" && event.result) {
                         resultText = typeof event.result === "string" ? event.result : "";
                     }
@@ -340,7 +367,35 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
                     continue;
                 try {
                     const event = JSON.parse(trimmed);
-                    if (event.type === "content_block_delta" && event.delta?.text) {
+                    // Claude CLI stream-json wraps content in assistant message events
+                    if (event.type === "assistant" && event.message?.content) {
+                        const content = event.message.content;
+                        if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block.type === "text" && block.text) {
+                                    fullText += block.text;
+                                    // Log analyst reasoning (first line, truncated)
+                                    const thought = block.text.trim().split("\n")[0].substring(0, 120);
+                                    if (thought) {
+                                        console.log(`${ts()} ${label} ${chalk.dim("💭")} ${chalk.dim(thought)}`);
+                                    }
+                                }
+                                else if (block.type === "tool_use") {
+                                    toolCalls++;
+                                    const toolName = block.name || "unknown";
+                                    // 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;
+                                    console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)}${inputPreview ? chalk.dim(` ${inputPreview}`) : ""} (${toolCalls} total)`);
+                                }
+                            }
+                        }
+                        else if (typeof content === "string") {
+                            fullText += content;
+                        }
+                    }
+                    else if (event.type === "content_block_delta" && event.delta?.text) {
+                        // Fallback: raw API streaming format (may appear in some CLI versions)
                         fullText += event.delta.text;
                     }
                     else if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {

package/dist/poller.d.ts

@@ -5,6 +5,11 @@
  * dispatch to planner or spawner based on task status.
  */
 import type { AgentConfig } from "./config.js";
+/**
+ * Stop all polling and heartbeat loops.
+ * Called during graceful shutdown to prevent the event loop from staying alive.
+ */
+export declare function stopPolling(): void;
 /**
  * Start the poll loop.
  */

package/dist/poller.js

@@ -235,6 +235,23 @@ async function handleManagerTask(task, config) {
         console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Failed to claim manager task:`, error.message || String(err));
     }
 }
+// Store interval IDs so they can be cleared on shutdown
+let pollIntervalId = null;
+let heartbeatIntervalId = null;
+/**
+ * Stop all polling and heartbeat loops.
+ * Called during graceful shutdown to prevent the event loop from staying alive.
+ */
+export function stopPolling() {
+    if (pollIntervalId) {
+        clearInterval(pollIntervalId);
+        pollIntervalId = null;
+    }
+    if (heartbeatIntervalId) {
+        clearInterval(heartbeatIntervalId);
+        heartbeatIntervalId = null;
+    }
+}
 /**
  * Start the poll loop.
  */
@@ -243,13 +260,13 @@ export function startPolling(config) {
     // Initial poll
     pollOnce(config);
     // Recurring poll
-    setInterval(() => pollOnce(config), config.pollIntervalMs);
+    pollIntervalId = setInterval(() => pollOnce(config), config.pollIntervalMs);
 }
 /**
  * Start the heartbeat loop.
  */
 export function startHeartbeat(config) {
-    setInterval(async () => {
+    heartbeatIntervalId = setInterval(async () => {
         // Include BOTH running containers AND tasks being planned/managed
         const containerTaskIds = getActiveTaskIds();
         const planningTaskIds = Array.from(planningInProgress);

package/package.json

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