@workermill/agent 0.3.1 → 0.4.0

package/dist/commands/start.js

@@ -25,14 +25,23 @@ export async function startCommand(options) {
     const failing = prereqs.filter((p) => !p.ok);
     // Auto-pull worker image if it's the only missing prereq
     const imageMissing = failing.find((p) => p.name === "Worker image");
-    const otherFailing = failing.filter((p) => p.name !== "Worker image");
-    if (otherFailing.length > 0) {
+    // Claude CLI and auth are soft prerequisites — only needed for Anthropic provider.
+    // Non-Anthropic orgs can plan+execute without Claude CLI.
+    const softPrereqs = new Set(["Claude CLI", "Claude auth"]);
+    const hardFailing = failing.filter((p) => p.name !== "Worker image" && !softPrereqs.has(p.name));
+    const softFailing = failing.filter((p) => softPrereqs.has(p.name));
+    if (hardFailing.length > 0) {
         console.log(chalk.red("Prerequisites check failed:"));
-        for (const p of otherFailing) {
+        for (const p of hardFailing) {
             console.log(chalk.red(`  ✗ ${p.name}: ${p.detail}`));
         }
         process.exit(1);
     }
+    if (softFailing.length > 0) {
+        for (const p of softFailing) {
+            console.log(chalk.yellow(`  ⚠ ${p.name}: ${p.detail} (required for Anthropic provider)`));
+        }
+    }
     if (imageMissing) {
         console.log(chalk.yellow(`  Worker image not found locally. Pulling ${config.workerImage}...`));
         const { spawnSync } = await import("child_process");

package/dist/config.d.ts

@@ -16,6 +16,7 @@ export interface AgentConfig {
     bitbucketToken: string;
     gitlabToken: string;
     workerImage: string;
+    teamPlanningEnabled: boolean;
 }
 export interface FileConfig {
     apiUrl: string;
@@ -30,6 +31,7 @@ export interface FileConfig {
         gitlab: string;
     };
     workerImage: string;
+    teamPlanningEnabled?: boolean;
     setupCompletedAt: string;
 }
 export declare function getConfigDir(): string;

package/dist/config.js

@@ -75,6 +75,7 @@ export function loadConfigFromFile() {
         bitbucketToken: fc.tokens?.bitbucket || "",
         gitlabToken: fc.tokens?.gitlab || "",
         workerImage,
+        teamPlanningEnabled: fc.teamPlanningEnabled ?? true,
     };
 }
 /**
@@ -119,6 +120,7 @@ export function loadConfig() {
         bitbucketToken: process.env.BITBUCKET_TOKEN || "",
         gitlabToken: process.env.GITLAB_TOKEN || "",
         workerImage: process.env.WORKER_IMAGE || "workermill-worker:local",
+        teamPlanningEnabled: process.env.TEAM_PLANNING_ENABLED !== "false",
     };
 }
 /**

package/dist/planner.d.ts

@@ -20,6 +20,8 @@ export interface PlanningTask {
     id: string;
     summary: string;
     description: string | null;
+    githubRepo?: string;
+    scmProvider?: string;
 }
 /**
  * Run planning for a task with Planner-Critic validation loop.

package/dist/planner.js

@@ -15,7 +15,7 @@
  * sees the same planning progress as cloud mode.
  */
 import chalk from "chalk";
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 import { findClaudePath } from "./config.js";
 import { api } from "./api.js";
 import { parseExecutionPlan, applyFileCap, serializePlan, runCriticValidation, formatCriticFeedback, AUTO_APPROVAL_THRESHOLD, } from "./plan-validator.js";
@@ -204,8 +204,8 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             clearInterval(progressInterval);
             clearInterval(sseProgressInterval);
             proc.kill("SIGTERM");
-            reject(new Error("Claude CLI timed out after 10 minutes"));
-        }, 600_000);
+            reject(new Error("Claude CLI timed out after 20 minutes"));
+        }, 1_200_000);
         proc.on("exit", (code) => {
             clearTimeout(timeout);
             clearInterval(progressInterval);
@@ -249,6 +249,199 @@ function resolveProviderApiKey(provider, credentials) {
             return undefined;
     }
 }
+/**
+ * Build a git clone URL with authentication for the given SCM provider.
+ */
+function buildCloneUrl(repo, token, scmProvider) {
+    switch (scmProvider) {
+        case "bitbucket":
+            return `https://x-token-auth:${token}@bitbucket.org/${repo}.git`;
+        case "gitlab":
+            return `https://oauth2:${token}@gitlab.com/${repo}.git`;
+        case "github":
+        default:
+            return `https://x-access-token:${token}@github.com/${repo}.git`;
+    }
+}
+/**
+ * Clone the target repo to a temp directory for team planning analysis.
+ * Returns the path on success, or null on failure (fallback to single-agent).
+ */
+async function cloneTargetRepo(repo, token, scmProvider, taskId) {
+    const taskLabel = chalk.cyan(taskId.slice(0, 8));
+    const tmpDir = `/tmp/workermill-planning-${taskId.slice(0, 8)}-${Date.now()}`;
+    try {
+        const cloneUrl = buildCloneUrl(repo, token, scmProvider);
+        console.log(`${ts()} ${taskLabel} ${chalk.dim("Cloning repo for team planning...")}`);
+        execSync(`git clone --depth 1 --single-branch "${cloneUrl}" "${tmpDir}"`, {
+            stdio: "ignore",
+            timeout: 60_000,
+        });
+        console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Repo cloned to ${chalk.dim(tmpDir)}`);
+        return tmpDir;
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        console.error(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} Clone failed, falling back to single-agent: ${errMsg.substring(0, 100)}`);
+        // Cleanup partial clone
+        try {
+            execSync(`rm -rf "${tmpDir}"`, { stdio: "ignore" });
+        }
+        catch {
+            /* ignore */
+        }
+        return null;
+    }
+}
+/**
+ * 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) {
+    return new Promise((resolve) => {
+        const proc = spawn(claudePath, [
+            "-p",
+            prompt,
+            "--model",
+            model,
+            "--permission-mode",
+            "bypassPermissions",
+            "--output-format",
+            "stream-json",
+        ], {
+            cwd: repoPath,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let resultText = "";
+        let fullText = "";
+        let lineBuffer = "";
+        proc.stdout.on("data", (data) => {
+            lineBuffer += data.toString();
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop() || "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const event = JSON.parse(trimmed);
+                    if (event.type === "content_block_delta" && event.delta?.text) {
+                        fullText += event.delta.text;
+                    }
+                    else if (event.type === "result" && event.result) {
+                        resultText =
+                            typeof event.result === "string" ? event.result : "";
+                    }
+                }
+                catch {
+                    fullText += trimmed + "\n";
+                }
+            }
+        });
+        const timeout = setTimeout(() => {
+            proc.kill("SIGTERM");
+            resolve(resultText || fullText || "");
+        }, timeoutMs);
+        proc.on("exit", () => {
+            clearTimeout(timeout);
+            resolve(resultText || fullText || "");
+        });
+        proc.on("error", () => {
+            clearTimeout(timeout);
+            resolve("");
+        });
+    });
+}
+/** Analyst prompt templates */
+const CODEBASE_ANALYST_PROMPT = `You are analyzing a codebase to help plan a development task.
+Use Glob and Read to explore the repository structure.
+Report:
+1. Key directories and their purposes
+2. Frameworks, languages, and patterns used
+3. Existing test patterns and locations
+4. CI/CD configuration
+5. Key configuration files (.env, tsconfig, etc.)
+Keep your report under 2000 words. Focus on facts, not opinions.`;
+function makeRequirementsAnalystPrompt(task) {
+    return `Given this task description:
+
+Title: ${task.summary}
+${task.description ? `\nDescription:\n${task.description}` : ""}
+
+Analyze the requirements and report:
+1. Explicit acceptance criteria (what MUST be done)
+2. Implicit requirements (what's assumed but not stated)
+3. Ambiguities that could lead to wrong implementation
+4. Affected components based on the requirement scope
+5. Suggested personas for each component
+Keep your report under 1500 words.`;
+}
+function makeRiskAssessorPrompt(task) {
+    return `You are assessing risks for a development task on this codebase.
+The task: ${task.summary}
+${task.description ? `\nDescription:\n${task.description}` : ""}
+
+Use Grep and Read to check for potential blockers.
+Report:
+1. Files likely to be modified (search for relevant code)
+2. Files that are heavily coupled (imports/dependencies)
+3. Existing tests that may need updating
+4. Environment/config dependencies
+5. Migration or deployment considerations
+Keep your report under 1500 words.`;
+}
+/**
+ * Run team planning: spawn 3 parallel analyst agents, then synthesize
+ * their reports into an enhanced planning prompt for the final planner.
+ *
+ * Falls back to single-agent planning if anything goes wrong.
+ */
+async function runTeamPlanning(task, basePrompt, claudePath, model, env, repoPath, taskId, startTime) {
+    const taskLabel = chalk.cyan(taskId.slice(0, 8));
+    console.log(`${ts()} ${taskLabel} ${chalk.magenta("◆ Team planning")} — running 3 analysts in parallel...`);
+    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);
+    // Build enhanced prompt with analysis reports
+    const sections = [];
+    if (codebaseReport) {
+        sections.push(`## Codebase Analysis (from automated analysis)\n\n${codebaseReport}`);
+    }
+    if (requirementsReport) {
+        sections.push(`## Requirements Analysis\n\n${requirementsReport}`);
+    }
+    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") +
+        "\n\n" +
+        "Use these analyses to produce a more accurate execution plan.\n" +
+        "Prefer actual file paths discovered in the codebase analysis over guessed paths.";
+    // Run the final synthesizer planner with the enhanced prompt
+    return runClaudeCli(claudePath, model, enhancedPrompt, env, taskId, startTime);
+}
 /**
  * Run planning for a task with Planner-Critic validation loop.
  *
@@ -281,6 +474,22 @@ export async function planTask(task, config, credentials) {
     const startTime = Date.now();
     // PRD for critic validation: use task description, fall back to summary
     const prd = task.description || task.summary;
+    // Clone repo for team planning if enabled
+    let repoPath = null;
+    if (isAnthropicPlanning && config.teamPlanningEnabled && task.githubRepo) {
+        const scmProvider = task.scmProvider || "github";
+        const scmToken = scmProvider === "bitbucket"
+            ? config.bitbucketToken
+            : scmProvider === "gitlab"
+                ? config.gitlabToken
+                : config.githubToken;
+        if (scmToken) {
+            repoPath = await cloneTargetRepo(task.githubRepo, scmToken, scmProvider, task.id);
+        }
+        else {
+            console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} No SCM token for ${scmProvider}, skipping team planning`);
+        }
+    }
     // 2. Planner-Critic iteration loop
     let currentPrompt = basePrompt;
     let bestPlan = null;
@@ -288,146 +497,167 @@ export async function planTask(task, config, credentials) {
     // Track critic history across iterations for analytics
     const criticHistory = [];
     let totalFileCapTruncations = 0;
-    for (let iteration = 1; iteration <= MAX_ITERATIONS; iteration++) {
-        const iterLabel = MAX_ITERATIONS > 1 ? ` (attempt ${iteration}/${MAX_ITERATIONS})` : "";
-        const providerLabel = `${provider}/${cliModel}`;
-        if (iteration > 1) {
-            console.log(`${ts()} ${taskLabel} Running planner${iterLabel} ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
-            await postLog(task.id, `${PREFIX} Re-planning${iterLabel} using ${providerLabel}`);
-        }
-        else {
-            console.log(`${ts()} ${taskLabel} Running planner ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
-            await postLog(task.id, `${PREFIX} Starting planning agent using ${providerLabel}`);
-        }
-        // 2a. Generate plan via Claude CLI (Anthropic) or HTTP API (other providers)
-        let rawOutput;
-        try {
-            if (isAnthropicPlanning) {
-                rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
+    try {
+        for (let iteration = 1; iteration <= MAX_ITERATIONS; iteration++) {
+            const iterLabel = MAX_ITERATIONS > 1 ? ` (attempt ${iteration}/${MAX_ITERATIONS})` : "";
+            const providerLabel = `${provider}/${cliModel}`;
+            if (iteration > 1) {
+                console.log(`${ts()} ${taskLabel} Running planner${iterLabel} ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
+                await postLog(task.id, `${PREFIX} Re-planning${iterLabel} using ${providerLabel}`);
             }
             else {
-                if (!providerApiKey) {
-                    throw new Error(`No API key available for provider "${provider}". Configure it in Settings > Integrations.`);
+                console.log(`${ts()} ${taskLabel} Running planner ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
+                await postLog(task.id, `${PREFIX} Starting planning agent using ${providerLabel}`);
+            }
+            // 2a. Generate plan via Claude CLI (Anthropic) or HTTP API (other providers)
+            let rawOutput;
+            try {
+                if (isAnthropicPlanning && config.teamPlanningEnabled && repoPath && iteration === 1) {
+                    rawOutput = await runTeamPlanning(task, currentPrompt, claudePath, cliModel, cleanEnv, repoPath, task.id, startTime);
+                }
+                else if (isAnthropicPlanning) {
+                    rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
+                }
+                else {
+                    if (!providerApiKey) {
+                        throw new Error(`No API key available for provider "${provider}". Configure it in Settings > Integrations.`);
+                    }
+                    const genStart = Math.round((Date.now() - startTime) / 1000);
+                    await postProgress(task.id, "generating_plan", genStart, "Generating plan via API...", 0, 0);
+                    rawOutput = await generateText(provider, cliModel, currentPrompt, providerApiKey);
+                    // Post "validating" phase so the dashboard progress bar transitions correctly
+                    const genEnd = Math.round((Date.now() - startTime) / 1000);
+                    await postProgress(task.id, "validating", genEnd, "Validating plan...", rawOutput.length, 0);
                 }
-                await postProgress(task.id, "generating_plan", 0, "Generating plan via API...", 0, 0);
-                rawOutput = await generateText(provider, cliModel, currentPrompt, providerApiKey);
             }
-        }
-        catch (error) {
+            catch (error) {
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                const errMsg = error instanceof Error ? error.message : String(error);
+                console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Failed after ${elapsed}s: ${errMsg.substring(0, 100)}`);
+                await postLog(task.id, `${PREFIX} Planning failed after ${formatElapsed(elapsed)}: ${errMsg.substring(0, 200)}`, "error", "error");
+                return false;
+            }
             const elapsed = Math.round((Date.now() - startTime) / 1000);
-            const errMsg = error instanceof Error ? error.message : String(error);
-            console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Failed after ${elapsed}s: ${errMsg.substring(0, 100)}`);
-            await postLog(task.id, `${PREFIX} Planning failed after ${formatElapsed(elapsed)}: ${errMsg.substring(0, 200)}`, "error", "error");
-            return false;
-        }
-        const elapsed = Math.round((Date.now() - startTime) / 1000);
-        console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Claude CLI done ${chalk.dim(`(${elapsed}s, ${rawOutput.length} chars)`)}`);
-        // 2b. Parse plan from raw output
-        let plan;
-        try {
-            plan = parseExecutionPlan(rawOutput);
-        }
-        catch (error) {
-            const errMsg = error instanceof Error ? error.message : String(error);
-            console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Plan parse failed: ${errMsg.substring(0, 100)}`);
-            await postLog(task.id, `${PREFIX} Failed to parse execution plan from Claude output: ${errMsg.substring(0, 200)}`, "error", "error");
-            // If we can't parse the plan, post raw output and let server-side try
-            return await postRawPlan(task.id, rawOutput, config.agentId, taskLabel, elapsed);
-        }
-        // 2c. Apply file cap (max 5 files per story)
-        const { truncatedCount, details } = applyFileCap(plan);
-        if (truncatedCount > 0) {
-            totalFileCapTruncations += truncatedCount;
-            const msg = `${PREFIX} File cap applied: ${truncatedCount} stories truncated to max 5 targetFiles`;
-            console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
-            await postLog(task.id, msg);
-            for (const detail of details) {
-                console.log(`${ts()} ${taskLabel}   ${chalk.dim(detail)}`);
+            const doneLabel = isAnthropicPlanning ? "Claude CLI" : `${provider} API`;
+            console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} ${doneLabel} done ${chalk.dim(`(${elapsed}s, ${rawOutput.length} chars)`)}`);
+            // 2b. Parse plan from raw output
+            let plan;
+            try {
+                plan = parseExecutionPlan(rawOutput);
             }
-        }
-        console.log(`${ts()} ${taskLabel} Plan: ${chalk.bold(plan.stories.length)} stories`);
-        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);
-        // Track best plan across iterations
-        if (criticResult && criticResult.score > bestScore) {
-            bestPlan = plan;
-            bestScore = criticResult.score;
-        }
-        else if (!criticResult && !bestPlan) {
-            // Critic failed entirely — use this plan as fallback
-            bestPlan = plan;
-        }
-        // Record critic history for this iteration
-        if (criticResult) {
-            criticHistory.push({
-                iteration,
-                score: criticResult.score,
-                approved: criticResult.approved || criticResult.score >= AUTO_APPROVAL_THRESHOLD,
-                risks: criticResult.risks,
-                suggestions: criticResult.suggestions,
-                filesCapApplied: truncatedCount > 0 ? truncatedCount : undefined,
-            });
-        }
-        // 2e. Check critic result
-        if (!criticResult) {
-            // Critic failed (timeout, parse error, etc.) — post plan without critic gate
-            const msg = `${PREFIX} Critic validation failed — posting plan without critic score`;
-            console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
-            await postLog(task.id, msg);
-            const planningDurationMs = Date.now() - startTime;
-            return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed, undefined, undefined, criticHistory, totalFileCapTruncations, planningDurationMs, iteration);
-        }
-        if (criticResult.approved || criticResult.score >= AUTO_APPROVAL_THRESHOLD) {
-            // Approved! Post the file-capped plan
-            const msg = `${PREFIX} Critic approved (score: ${criticResult.score}/100)`;
-            console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} ${msg}`);
-            await postLog(task.id, msg);
-            if (criticResult.risks.length > 0) {
-                const risksMsg = `${PREFIX} Critic risks (non-blocking): ${criticResult.risks.join("; ")}`;
-                console.log(`${ts()} ${taskLabel}   ${chalk.dim(risksMsg)}`);
-                await postLog(task.id, risksMsg);
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Plan parse failed: ${errMsg.substring(0, 100)}`);
+                await postLog(task.id, `${PREFIX} Failed to parse execution plan from Claude output: ${errMsg.substring(0, 200)}`, "error", "error");
+                // If we can't parse the plan, post raw output and let server-side try
+                return await postRawPlan(task.id, rawOutput, config.agentId, taskLabel, elapsed);
             }
-            const planningDurationMs = Date.now() - startTime;
-            return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed, criticResult.score, criticResult.risks, criticHistory, totalFileCapTruncations, planningDurationMs, iteration);
-        }
-        // 2f. Rejected — append critic feedback for next iteration
-        if (iteration < MAX_ITERATIONS) {
-            const feedback = formatCriticFeedback(criticResult);
-            currentPrompt = basePrompt + "\n\n" + feedback;
-            const msg = `${PREFIX} Critic rejected (score: ${criticResult.score}/100, threshold: ${AUTO_APPROVAL_THRESHOLD}). Re-planning with feedback...`;
-            console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
-            await postLog(task.id, msg);
-            if (criticResult.risks.length > 0) {
-                const risksMsg = `${PREFIX} Critic risks: ${criticResult.risks.join("; ")}`;
-                console.log(`${ts()} ${taskLabel}   ${chalk.dim(risksMsg)}`);
-                await postLog(task.id, risksMsg);
+            // 2c. Apply file cap (max 5 files per story)
+            const { truncatedCount, details } = applyFileCap(plan);
+            if (truncatedCount > 0) {
+                totalFileCapTruncations += truncatedCount;
+                const msg = `${PREFIX} File cap applied: ${truncatedCount} stories truncated to max 5 targetFiles`;
+                console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
+                await postLog(task.id, msg);
+                for (const detail of details) {
+                    console.log(`${ts()} ${taskLabel}   ${chalk.dim(detail)}`);
+                }
+            }
+            console.log(`${ts()} ${taskLabel} Plan: ${chalk.bold(plan.stories.length)} stories`);
+            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);
+            // Track best plan across iterations
+            if (criticResult && criticResult.score > bestScore) {
+                bestPlan = plan;
+                bestScore = criticResult.score;
+            }
+            else if (!criticResult && !bestPlan) {
+                // Critic failed entirely — use this plan as fallback
+                bestPlan = plan;
             }
-            if (criticResult.suggestions && criticResult.suggestions.length > 0) {
-                const sugMsg = `${PREFIX} Critic suggestions: ${criticResult.suggestions.join("; ")}`;
-                console.log(`${ts()} ${taskLabel}   ${chalk.dim(sugMsg)}`);
-                await postLog(task.id, sugMsg);
+            // Record critic history for this iteration
+            if (criticResult) {
+                criticHistory.push({
+                    iteration,
+                    score: criticResult.score,
+                    approved: criticResult.approved || criticResult.score >= AUTO_APPROVAL_THRESHOLD,
+                    risks: criticResult.risks,
+                    suggestions: criticResult.suggestions,
+                    filesCapApplied: truncatedCount > 0 ? truncatedCount : undefined,
+                });
+            }
+            // 2e. Check critic result
+            if (!criticResult) {
+                // Critic failed (timeout, parse error, etc.) — post plan without critic gate
+                const msg = `${PREFIX} Critic validation failed — posting plan without critic score`;
+                console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
+                await postLog(task.id, msg);
+                const planningDurationMs = Date.now() - startTime;
+                return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed, undefined, undefined, criticHistory, totalFileCapTruncations, planningDurationMs, iteration);
+            }
+            if (criticResult.approved || criticResult.score >= AUTO_APPROVAL_THRESHOLD) {
+                // Approved! Post the file-capped plan
+                const msg = `${PREFIX} Critic approved (score: ${criticResult.score}/100)`;
+                console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} ${msg}`);
+                await postLog(task.id, msg);
+                if (criticResult.risks.length > 0) {
+                    const risksMsg = `${PREFIX} Critic risks (non-blocking): ${criticResult.risks.join("; ")}`;
+                    console.log(`${ts()} ${taskLabel}   ${chalk.dim(risksMsg)}`);
+                    await postLog(task.id, risksMsg);
+                }
+                const planningDurationMs = Date.now() - startTime;
+                return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed, criticResult.score, criticResult.risks, criticHistory, totalFileCapTruncations, planningDurationMs, iteration);
+            }
+            // 2f. Rejected — append critic feedback for next iteration
+            if (iteration < MAX_ITERATIONS) {
+                const feedback = formatCriticFeedback(criticResult);
+                currentPrompt = basePrompt + "\n\n" + feedback;
+                const msg = `${PREFIX} Critic rejected (score: ${criticResult.score}/100, threshold: ${AUTO_APPROVAL_THRESHOLD}). Re-planning with feedback...`;
+                console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
+                await postLog(task.id, msg);
+                if (criticResult.risks.length > 0) {
+                    const risksMsg = `${PREFIX} Critic risks: ${criticResult.risks.join("; ")}`;
+                    console.log(`${ts()} ${taskLabel}   ${chalk.dim(risksMsg)}`);
+                    await postLog(task.id, risksMsg);
+                }
+                if (criticResult.suggestions && criticResult.suggestions.length > 0) {
+                    const sugMsg = `${PREFIX} Critic suggestions: ${criticResult.suggestions.join("; ")}`;
+                    console.log(`${ts()} ${taskLabel}   ${chalk.dim(sugMsg)}`);
+                    await postLog(task.id, sugMsg);
+                }
+            }
+            else {
+                // Final iteration — rejected
+                const msg = `${PREFIX} Critic rejected after ${MAX_ITERATIONS} iterations (best score: ${bestScore}/100, threshold: ${AUTO_APPROVAL_THRESHOLD})`;
+                console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} ${msg}`);
+                await postLog(task.id, msg, "error", "error");
+                if (criticResult.risks.length > 0) {
+                    const risksMsg = `${PREFIX} Final risks: ${criticResult.risks.join("; ")}`;
+                    console.error(`${ts()} ${taskLabel}   ${risksMsg}`);
+                    await postLog(task.id, risksMsg, "error", "error");
+                }
+                if (criticResult.suggestions && criticResult.suggestions.length > 0) {
+                    const sugMsg = `${PREFIX} Suggestions: ${criticResult.suggestions.join("; ")}`;
+                    console.error(`${ts()} ${taskLabel}   ${sugMsg}`);
+                    await postLog(task.id, sugMsg, "error", "error");
+                }
             }
         }
-        else {
-            // Final iteration — rejected
-            const msg = `${PREFIX} Critic rejected after ${MAX_ITERATIONS} iterations (best score: ${bestScore}/100, threshold: ${AUTO_APPROVAL_THRESHOLD})`;
-            console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} ${msg}`);
-            await postLog(task.id, msg, "error", "error");
-            if (criticResult.risks.length > 0) {
-                const risksMsg = `${PREFIX} Final risks: ${criticResult.risks.join("; ")}`;
-                console.error(`${ts()} ${taskLabel}   ${risksMsg}`);
-                await postLog(task.id, risksMsg, "error", "error");
+        // All iterations exhausted — fail
+        return false;
+    }
+    finally {
+        // Cleanup temp clone
+        if (repoPath) {
+            try {
+                execSync(`rm -rf "${repoPath}"`, { stdio: "ignore" });
             }
-            if (criticResult.suggestions && criticResult.suggestions.length > 0) {
-                const sugMsg = `${PREFIX} Suggestions: ${criticResult.suggestions.join("; ")}`;
-                console.error(`${ts()} ${taskLabel}   ${sugMsg}`);
-                await postLog(task.id, sugMsg, "error", "error");
+            catch {
+                /* ignore */
             }
         }
     }
-    // All iterations exhausted — fail
-    return false;
 }
 /**
  * Post a validated (file-capped) plan to the cloud API.

package/dist/spawner.js

@@ -132,17 +132,20 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
     else {
         dockerArgs.push("--network", "host");
     }
-    // Mount Claude credentials
+    // Mount Claude credentials (required for Anthropic workers, optional for others)
+    const workerProvider = task.workerProvider || "anthropic";
     const claudeConfigDir = findClaudeConfigDir();
-    if (!claudeConfigDir) {
+    if (!claudeConfigDir && workerProvider === "anthropic") {
         console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Claude credentials not found. Run 'claude' and complete the sign-in flow.`);
         return;
     }
-    // Copy credentials to a temp dir with relaxed permissions for container access
-    // (avoids weakening permissions on the user's actual credentials file)
-    const credFile = path.join(claudeConfigDir, ".credentials.json");
-    const dockerClaudeDir = toDockerPath(claudeConfigDir);
-    dockerArgs.push("-v", `${dockerClaudeDir}:/home/worker/.claude`);
+    if (claudeConfigDir) {
+        const dockerClaudeDir = toDockerPath(claudeConfigDir);
+        dockerArgs.push("-v", `${dockerClaudeDir}:/home/worker/.claude`);
+    }
+    else {
+        console.log(`${ts()} ${taskLabel} ${chalk.dim("Skipping Claude mount (non-Anthropic worker)")}`);
+    }
     // Build environment variables — KEY DIFFERENCE: API_BASE_URL points to cloud
     const scmProvider = (task.scmProvider || "github");
     const scmToken = getScmToken(scmProvider, config);

package/package.json

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