@workermill/agent 0.3.0 → 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/plan-validator.d.ts

@@ -9,6 +9,7 @@
  * This ensures remote agent plans get the same quality gates as cloud plans,
  * even though the planning prompt runs locally via Claude CLI.
  */
+import { type AIProvider } from "./providers.js";
 export interface PlannedStory {
     id: string;
     title: string;
@@ -76,7 +77,8 @@ export declare function runCriticCli(claudePath: string, model: string, prompt:
 export declare function formatCriticFeedback(critic: CriticResult): string;
 /**
  * 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 declare function runCriticValidation(claudePath: string, model: string, prd: string, plan: ExecutionPlan, env: Record<string, string | undefined>, taskLabel: 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): Promise<CriticResult | null>;
 export { AUTO_APPROVAL_THRESHOLD };

package/dist/plan-validator.js

@@ -11,6 +11,7 @@
  */
 import { spawn } from "child_process";
 import chalk from "chalk";
+import { generateText } from "./providers.js";
 // ============================================================================
 // CONSTANTS
 // ============================================================================
@@ -245,13 +246,24 @@ function ts() {
 }
 /**
  * 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) {
+export async function runCriticValidation(claudePath, model, prd, plan, env, taskLabel, provider, providerApiKey) {
     const criticPrompt = buildCriticPrompt(prd, plan);
-    console.log(`${ts()} ${taskLabel} ${chalk.dim("Running critic validation...")}`);
+    const effectiveProvider = provider || "anthropic";
+    console.log(`${ts()} ${taskLabel} ${chalk.dim(`Running critic validation (${effectiveProvider})...`)}`);
     try {
-        const rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env);
+        let rawCriticOutput;
+        if (effectiveProvider === "anthropic") {
+            rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env);
+        }
+        else {
+            if (!providerApiKey) {
+                throw new Error(`No API key for critic provider "${effectiveProvider}"`);
+            }
+            rawCriticOutput = await generateText(effectiveProvider, model, criticPrompt, providerApiKey, { maxTokens: 4096, temperature: 0.3, timeoutMs: 180_000 });
+        }
         const result = parseCriticResponse(rawCriticOutput);
         const statusIcon = result.score >= AUTO_APPROVAL_THRESHOLD
             ? chalk.green("✓")

package/dist/planner.d.ts

@@ -15,10 +15,13 @@
  * sees the same planning progress as cloud mode.
  */
 import { type AgentConfig } from "./config.js";
+import type { ClaimCredentials } from "./spawner.js";
 export interface PlanningTask {
     id: string;
     summary: string;
     description: string | null;
+    githubRepo?: string;
+    scmProvider?: string;
 }
 /**
  * Run planning for a task with Planner-Critic validation loop.
@@ -32,4 +35,4 @@ export interface PlanningTask {
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
  *   7. After MAX_ITERATIONS without approval: fail the task
  */
-export declare function planTask(task: PlanningTask, config: AgentConfig): Promise<boolean>;
+export declare function planTask(task: PlanningTask, config: AgentConfig, credentials?: ClaimCredentials): Promise<boolean>;

package/dist/planner.js

@@ -15,10 +15,11 @@
  * 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";
+import { generateText } from "./providers.js";
 /** Max Planner-Critic iterations before giving up */
 const MAX_ITERATIONS = 3;
 /** Timestamp prefix */
@@ -203,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);
@@ -228,6 +229,219 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         });
     });
 }
+/**
+ * Resolve the API key for a given provider from claim credentials.
+ * For Ollama, returns the base URL instead of an API key.
+ */
+function resolveProviderApiKey(provider, credentials) {
+    if (!credentials)
+        return undefined;
+    switch (provider) {
+        case "anthropic":
+            return credentials.anthropicApiKey;
+        case "openai":
+            return credentials.openaiApiKey;
+        case "google":
+            return credentials.googleApiKey;
+        case "ollama":
+            return credentials.ollamaBaseUrl || "http://localhost:11434";
+        default:
+            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.
  *
@@ -240,7 +454,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
  *   7. After MAX_ITERATIONS without approval: fail the task
  */
-export async function planTask(task, config) {
+export async function planTask(task, config, credentials) {
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
     console.log(`${ts()} ${taskLabel} Fetching planning prompt...`);
     await postLog(task.id, `${PREFIX} Fetching planning prompt from cloud API...`);
@@ -248,14 +462,34 @@ export async function planTask(task, config) {
     const promptResponse = await api.get("/api/agent/planning-prompt", {
         params: { taskId: task.id },
     });
-    const { prompt: basePrompt, model } = promptResponse.data;
+    const { prompt: basePrompt, model, provider: planningProvider } = promptResponse.data;
     const cliModel = model || "sonnet";
+    const provider = (planningProvider || "anthropic");
+    const isAnthropicPlanning = provider === "anthropic";
     const claudePath = process.env.CLAUDE_CLI_PATH || findClaudePath() || "claude";
     const cleanEnv = { ...process.env };
     delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    // Resolve provider API key for non-Anthropic planning
+    const providerApiKey = resolveProviderApiKey(provider, 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;
@@ -263,136 +497,167 @@ export async function planTask(task, config) {
     // 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})` : "";
-        if (iteration > 1) {
-            console.log(`${ts()} ${taskLabel} Running Claude CLI${iterLabel} ${chalk.dim(`(model: ${chalk.yellow(cliModel)})`)}`);
-            await postLog(task.id, `${PREFIX} Re-planning${iterLabel} using anthropic/${cliModel}`);
-        }
-        else {
-            console.log(`${ts()} ${taskLabel} Running Claude CLI ${chalk.dim(`(model: ${chalk.yellow(cliModel)})`)}`);
-            await postLog(task.id, `${PREFIX} Starting planning agent using anthropic/${cliModel}`);
-        }
-        // 2a. Run Claude CLI to generate plan
-        let rawOutput;
-        try {
-            rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
-        }
-        catch (error) {
+    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 {
+                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);
+                }
+            }
+            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);
-        // 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;
             }
-            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 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);
+                }
+                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/poller.js

@@ -7,7 +7,7 @@
 import chalk from "chalk";
 import { api } from "./api.js";
 import { planTask } from "./planner.js";
-import { spawnWorker, getActiveCount, getActiveTaskIds, stopTask } from "./spawner.js";
+import { spawnWorker, getActiveCount, getActiveTaskIds, stopTask, } from "./spawner.js";
 import { AGENT_VERSION } from "./version.js";
 import { selfUpdate, restartAgent } from "./updater.js";
 // Track tasks currently being planned (to avoid double-dispatching)
@@ -76,7 +76,8 @@ async function pollOnce(config) {
  * Handle a task in "planning" status.
  */
 async function handlePlanningTask(task, config) {
-    // Claim the task
+    // Claim the task (also returns org credentials for provider API keys)
+    let credentials;
     try {
         const claimResponse = await api.post("/api/agent/claim", {
             taskId: task.id,
@@ -85,6 +86,7 @@ async function handlePlanningTask(task, config) {
         if (!claimResponse.data.claimed) {
             return; // Another agent or cloud orchestrator claimed it
         }
+        credentials = claimResponse.data.credentials;
     }
     catch {
         return;
@@ -94,7 +96,7 @@ async function handlePlanningTask(task, config) {
     console.log(`${ts()} ${chalk.magenta("◆ PLANNING")} ${taskLabel} ${task.summary.substring(0, 60)}`);
     planningInProgress.add(task.id);
     // Run planning asynchronously (don't block the poll loop)
-    planTask(task, config)
+    planTask(task, config, credentials)
         .then((success) => {
         if (success) {
             console.log(`${ts()} ${chalk.green("✓")} Planning complete for ${taskLabel}`);

package/dist/providers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lightweight HTTP wrappers for text generation across AI providers.
+ *
+ * Used for planning and critic stages when the org's provider is not Anthropic.
+ * No heavy SDK dependencies — uses the existing axios dependency for HTTP calls.
+ * Streaming is not needed (planning/critic are text-only, result matters).
+ */
+export type AIProvider = "anthropic" | "openai" | "google" | "ollama";
+export interface GenerateTextOptions {
+    maxTokens?: number;
+    temperature?: number;
+    timeoutMs?: number;
+}
+/**
+ * Generate text from any supported AI provider via direct HTTP API calls.
+ * Returns the raw text response.
+ */
+export declare function generateText(provider: AIProvider, model: string, prompt: string, apiKey: string, options?: GenerateTextOptions): Promise<string>;

package/dist/providers.js

@@ -0,0 +1,118 @@
+/**
+ * Lightweight HTTP wrappers for text generation across AI providers.
+ *
+ * Used for planning and critic stages when the org's provider is not Anthropic.
+ * No heavy SDK dependencies — uses the existing axios dependency for HTTP calls.
+ * Streaming is not needed (planning/critic are text-only, result matters).
+ */
+import axios from "axios";
+const DEFAULT_MAX_TOKENS = 16384;
+const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes (matches Claude CLI timeout)
+/**
+ * Generate text from any supported AI provider via direct HTTP API calls.
+ * Returns the raw text response.
+ */
+export async function generateText(provider, model, prompt, apiKey, options) {
+    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const temperature = options?.temperature ?? 0.7;
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    switch (provider) {
+        case "anthropic":
+            return generateAnthropic(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        case "openai":
+            return generateOpenAI(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        case "google":
+            return generateGoogle(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        case "ollama":
+            return generateOllama(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        default:
+            throw new Error(`Unsupported AI provider: ${provider}`);
+    }
+}
+/**
+ * Anthropic Messages API (for orgs with API key, not CLI).
+ */
+async function generateAnthropic(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
+    const response = await axios.post("https://api.anthropic.com/v1/messages", {
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        messages: [{ role: "user", content: prompt }],
+    }, {
+        headers: {
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01",
+            "Content-Type": "application/json",
+        },
+        timeout: timeoutMs,
+    });
+    const content = response.data?.content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+    }
+    throw new Error("Unexpected Anthropic API response format");
+}
+/**
+ * OpenAI Chat Completions API.
+ */
+async function generateOpenAI(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
+    const response = await axios.post("https://api.openai.com/v1/chat/completions", {
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        messages: [{ role: "user", content: prompt }],
+    }, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        timeout: timeoutMs,
+    });
+    const message = response.data?.choices?.[0]?.message;
+    if (message?.content)
+        return message.content;
+    throw new Error("Unexpected OpenAI API response format");
+}
+/**
+ * Google Generative AI (Gemini) API.
+ */
+async function generateGoogle(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
+    const response = await axios.post(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`, {
+        contents: [{ parts: [{ text: prompt }] }],
+        generationConfig: {
+            maxOutputTokens: maxTokens,
+            temperature,
+        },
+    }, {
+        headers: { "Content-Type": "application/json" },
+        timeout: timeoutMs,
+    });
+    const candidate = response.data?.candidates?.[0];
+    const text = candidate?.content?.parts?.[0]?.text;
+    if (text)
+        return text;
+    throw new Error("Unexpected Google AI API response format");
+}
+/**
+ * Ollama Generate API (self-hosted).
+ * `apiKey` is used as the Ollama base URL (e.g. "http://localhost:11434").
+ */
+async function generateOllama(model, prompt, ollamaHost, _maxTokens, temperature, timeoutMs) {
+    const baseUrl = ollamaHost || "http://localhost:11434";
+    const response = await axios.post(`${baseUrl}/api/generate`, {
+        model,
+        prompt,
+        stream: false,
+        options: { temperature },
+    }, {
+        headers: { "Content-Type": "application/json" },
+        timeout: timeoutMs,
+    });
+    const text = response.data?.response;
+    if (text)
+        return text;
+    throw new Error("Unexpected Ollama API response format");
+}

package/dist/spawner.d.ts

@@ -14,6 +14,7 @@ export interface SpawnableTask {
     description: string | null;
     jiraIssueKey: string | null;
     workerModel: string;
+    workerProvider?: string;
     githubRepo: string;
     scmProvider: string;
     skipManagerReview?: boolean;
@@ -34,6 +35,10 @@ export interface ClaimCredentials {
     customerAwsRegion?: string;
     issueTrackerProvider?: string;
     bitbucketEmail?: string;
+    anthropicApiKey?: string;
+    openaiApiKey?: string;
+    googleApiKey?: string;
+    ollamaBaseUrl?: string;
 }
 /**
  * Spawn a Docker worker container for a task.

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);
@@ -193,8 +196,13 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         BITBUCKET_EMAIL: credentials?.bitbucketEmail || "",
         // Task notes from dashboard
         TASK_NOTES: task.taskNotes || "",
-        // Anthropic API key (if available)
-        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
+        // AI provider configuration
+        ANTHROPIC_API_KEY: credentials?.anthropicApiKey || process.env.ANTHROPIC_API_KEY || "",
+        WORKER_PROVIDER: task.workerProvider || "anthropic",
+        OPENAI_API_KEY: credentials?.openaiApiKey || "",
+        GOOGLE_API_KEY: credentials?.googleApiKey || "",
+        GOOGLE_GENERATIVE_AI_API_KEY: credentials?.googleApiKey || "",
+        OLLAMA_HOST: credentials?.ollamaBaseUrl || "",
         // Resilience settings from org config
         BLOCKER_MAX_AUTO_RETRIES: String(orgConfig.blockerMaxAutoRetries ?? 3),
         BLOCKER_AUTO_RETRY_ENABLED: orgConfig.blockerAutoRetryEnabled !== false ? "true" : "false",

package/package.json

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