@workermill/agent 0.7.16 → 0.7.18

package/dist/planner.js

@@ -20,6 +20,50 @@ import { findClaudePath } from "./config.js";
 import { api } from "./api.js";
 import { parseExecutionPlan, applyFileCap, applyStoryCap, resolveFileOverlaps, serializePlan, runCriticValidation, formatCriticFeedback, AUTO_APPROVAL_THRESHOLD, } from "./plan-validator.js";
 import { generateTextWithTools } from "./ai-sdk-generate.js";
+/**
+ * Extract token usage from a stream-json event.
+ * Claude reports cumulative tokens, so we use Math.max to track the highest values.
+ */
+function extractTokenUsage(event, usage) {
+    const paths = [
+        event.usage,
+        event.message?.usage,
+        event.result?.usage,
+    ];
+    for (const u of paths) {
+        if (u && typeof u === "object") {
+            const d = u;
+            if (typeof d.input_tokens === "number")
+                usage.inputTokens = Math.max(usage.inputTokens, d.input_tokens);
+            if (typeof d.output_tokens === "number")
+                usage.outputTokens = Math.max(usage.outputTokens, d.output_tokens);
+            if (typeof d.cache_creation_input_tokens === "number")
+                usage.cacheCreationTokens = Math.max(usage.cacheCreationTokens, d.cache_creation_input_tokens);
+            if (typeof d.cache_read_input_tokens === "number")
+                usage.cacheReadTokens = Math.max(usage.cacheReadTokens, d.cache_read_input_tokens);
+        }
+    }
+}
+/**
+ * Report partial token usage to the cloud API.
+ */
+async function reportPlanningUsage(taskId, usage, model, mode) {
+    if (usage.inputTokens === 0 && usage.outputTokens === 0)
+        return;
+    try {
+        await api.post(`/api/tasks/${taskId}/usage/partial`, {
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            model,
+            mode,
+        });
+    }
+    catch {
+        // Fire and forget
+    }
+}
 /** Max Planner-Critic iterations before giving up */
 const MAX_ITERATIONS = 3;
 /** Timestamp prefix */
@@ -83,16 +127,22 @@ function phaseLabel(phase, elapsed) {
  * Run Claude CLI with stream-json output, posting real-time phase milestones
  * to the cloud dashboard — identical terminal experience to cloud planning.
  */
-function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
+function runClaudeCli(claudePath, model, prompt, env, taskId, startTime, disableTools = false) {
     const taskLabel = chalk.cyan(taskId.slice(0, 8));
     return new Promise((resolve, reject) => {
-        const proc = spawn(claudePath, [
+        const cliArgs = [
             "--print",
             "--verbose",
             "--output-format", "stream-json",
             "--model", model,
             "--permission-mode", "bypassPermissions",
-        ], {
+        ];
+        // When analysts already explored the repo, strip tools so the planner
+        // doesn't waste turns re-exploring — it has all context in the prompt.
+        if (disableTools) {
+            cliArgs.push("--allowedTools", "");
+        }
+        const proc = spawn(claudePath, cliArgs, {
             env,
             stdio: ["pipe", "pipe", "pipe"],
         });
@@ -103,6 +153,9 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         let stderrOutput = "";
         let charsReceived = 0;
         let toolCallCount = 0;
+        // Token usage accumulator — extract from stream events using Math.max
+        const tokenUsage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
+        let resultModel = model;
         // 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
@@ -240,6 +293,16 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                     else if (event.type === "result" && event.result) {
                         resultText = typeof event.result === "string" ? event.result : "";
                     }
+                    // Extract token usage from any event that carries it
+                    extractTokenUsage(event, tokenUsage);
+                    if (event.type === "result" && event.total_cost_usd !== undefined) {
+                        // Result event also carries model info
+                        if (event.modelUsage && typeof event.modelUsage === "object") {
+                            const models = Object.keys(event.modelUsage);
+                            if (models.length > 0)
+                                resultModel = models[0];
+                        }
+                    }
                 }
                 catch {
                     // Not valid JSON — raw text, accumulate
@@ -251,10 +314,17 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         proc.stderr.on("data", (chunk) => {
             stderrOutput += chunk.toString();
         });
+        // Report partial token usage every 30s during planning
+        const usageReportInterval = setInterval(() => {
+            if (tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0) {
+                reportPlanningUsage(taskId, tokenUsage, resultModel, "greatest").catch(() => { });
+            }
+        }, 30_000);
         function cleanupAll() {
             clearInterval(progressInterval);
             clearInterval(sseProgressInterval);
             clearInterval(textFlushInterval);
+            clearInterval(usageReportInterval);
             flushTextBuffer(true);
         }
         const timeout = setTimeout(() => {
@@ -268,6 +338,8 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             // Emit final "validating" phase to dashboard
             const elapsedAtClose = Math.round((Date.now() - startTime) / 1000);
             postProgress(taskId, "validating", elapsedAtClose, "Validating plan...", charsReceived, toolCallCount);
+            // Final usage report
+            reportPlanningUsage(taskId, tokenUsage, resultModel, "greatest").catch(() => { });
             if (code !== 0) {
                 reject(new Error(`Claude CLI failed (exit ${code}): ${stderrOutput.substring(0, 300)}`));
             }
@@ -766,7 +838,9 @@ export async function planTask(task, config, credentials) {
             let rawOutput;
             try {
                 if (isAnthropicPlanning) {
-                    rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
+                    // Disable tools when analysts already provided repo context
+                    const hasAnalystContext = enhancedBasePrompt !== basePrompt;
+                    rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime, hasAnalystContext);
                 }
                 else {
                     if (!providerApiKey) {

package/dist/spawner.js

@@ -140,6 +140,17 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         return;
     }
     if (claudeConfigDir) {
+        // Ensure credentials file is readable AND writable inside container.
+        // Claude CLI creates .credentials.json with 600 permissions, but the container
+        // runs as UID 1001 (worker) while the host user is UID 1000. Without this chmod,
+        // the mounted file is unreadable inside the container → "Invalid API key" errors.
+        const credFile = path.join(claudeConfigDir, ".credentials.json");
+        try {
+            fs.chmodSync(credFile, 0o666);
+        }
+        catch {
+            // Ignore - file may not exist yet
+        }
         const dockerClaudeDir = toDockerPath(claudeConfigDir);
         dockerArgs.push("-v", `${dockerClaudeDir}:/home/worker/.claude`);
     }

package/package.json

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