@workermill/agent 0.5.2 → 0.6.1

package/dist/plan-validator.js

@@ -183,8 +183,8 @@ export function runCriticCli(claudePath, model, prompt, env) {
         });
         const timeout = setTimeout(() => {
             proc.kill("SIGTERM");
-            reject(new Error("Critic CLI timed out after 3 minutes"));
-        }, 180_000);
+            reject(new Error("Critic CLI timed out after 10 minutes"));
+        }, 600_000);
         proc.on("exit", (code) => {
             clearTimeout(timeout);
             if (code !== 0) {
@@ -262,7 +262,7 @@ export async function runCriticValidation(claudePath, model, prd, plan, env, tas
             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 });
+            rawCriticOutput = await generateText(effectiveProvider, model, criticPrompt, providerApiKey, { maxTokens: 4096, temperature: 0.3, timeoutMs: 600_000 });
         }
         const result = parseCriticResponse(rawCriticOutput);
         const statusIcon = result.score >= AUTO_APPROVAL_THRESHOLD

package/dist/planner.js

@@ -456,7 +456,15 @@ Keep your report under 1500 words. Only report facts you verified with tools.`;
  *
  * Falls back to single-agent planning if anything goes wrong.
  */
-async function runTeamPlanning(task, basePrompt, claudePath, model, env, repoPath, taskId, startTime) {
+/**
+ * Run team analysis: spawn 3 parallel analyst agents once, then return
+ * an enhanced prompt with their reports appended. Returns null if all
+ * analysts fail (caller should fall back to basePrompt).
+ *
+ * This runs ONCE before the planner-critic loop — analyst prompts don't
+ * include critic feedback, so re-running them on iteration 2+ is waste.
+ */
+async function runTeamAnalysis(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...`);
@@ -497,7 +505,7 @@ async function runTeamPlanning(task, basePrompt, claudePath, model, env, repoPat
         if (attempt === MAX_TEAM_RETRIES) {
             console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} All analysts failed after ${MAX_TEAM_RETRIES} attempts, falling back to single-agent planning`);
             await postLog(taskId, `${PREFIX} All analysis agents failed after ${MAX_TEAM_RETRIES} attempts — falling back to single-agent planning`);
-            return runClaudeCli(claudePath, model, basePrompt, env, taskId, startTime);
+            return null;
         }
     }
     // Build enhanced prompt with analysis reports
@@ -511,14 +519,12 @@ async function runTeamPlanning(task, basePrompt, claudePath, model, env, repoPat
     if (riskReport) {
         sections.push(`## Risk Assessment\n\n${riskReport}`);
     }
-    const enhancedPrompt = basePrompt +
+    return (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);
+        "Prefer actual file paths discovered in the codebase analysis over guessed paths.");
 }
 /**
  * Run planning for a task with Planner-Critic validation loop.
@@ -552,8 +558,11 @@ 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
+    // Run team analysis ONCE before the planner-critic loop.
+    // Analyst prompts don't include critic feedback, so re-running them
+    // on iteration 2+ wastes compute (they'd produce the same reports).
     let repoPath = null;
+    let enhancedBasePrompt = basePrompt;
     if (isAnthropicPlanning && config.teamPlanningEnabled && task.githubRepo) {
         const scmProvider = task.scmProvider || "github";
         const scmToken = scmProvider === "bitbucket"
@@ -567,9 +576,18 @@ export async function planTask(task, config, credentials) {
         else {
             console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} No SCM token for ${scmProvider}, skipping team planning`);
         }
+        if (repoPath) {
+            const analysisResult = await runTeamAnalysis(task, basePrompt, claudePath, cliModel, cleanEnv, repoPath, task.id, startTime);
+            if (analysisResult) {
+                enhancedBasePrompt = analysisResult;
+            }
+            // else: all analysts failed, fall back to basePrompt
+        }
     }
     // 2. Planner-Critic iteration loop
-    let currentPrompt = basePrompt;
+    // Use enhancedBasePrompt (with analyst reports) as the base for all iterations.
+    // Critic feedback gets appended on re-plan, but analyst reports are fixed.
+    let currentPrompt = enhancedBasePrompt;
     let bestPlan = null;
     let bestScore = 0;
     // Track critic history across iterations for analytics
@@ -590,10 +608,7 @@ export async function planTask(task, config, credentials) {
             // 2a. Generate plan via Claude CLI (Anthropic) or HTTP API (other providers)
             let rawOutput;
             try {
-                if (isAnthropicPlanning && config.teamPlanningEnabled && repoPath) {
-                    rawOutput = await runTeamPlanning(task, currentPrompt, claudePath, cliModel, cleanEnv, repoPath, task.id, startTime);
-                }
-                else if (isAnthropicPlanning) {
+                if (isAnthropicPlanning) {
                     rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
                 }
                 else {
@@ -690,7 +705,7 @@ export async function planTask(task, config, credentials) {
             // 2f. Rejected — append critic feedback for next iteration
             if (iteration < MAX_ITERATIONS) {
                 const feedback = formatCriticFeedback(criticResult);
-                currentPrompt = basePrompt + "\n\n" + feedback;
+                currentPrompt = enhancedBasePrompt + "\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);

package/dist/poller.js

@@ -7,11 +7,13 @@
 import chalk from "chalk";
 import { api } from "./api.js";
 import { planTask } from "./planner.js";
-import { spawnWorker, getActiveCount, getActiveTaskIds, stopTask, } from "./spawner.js";
+import { spawnWorker, spawnManagerWorker, 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)
 const planningInProgress = new Set();
+// Track manager tasks in progress (to avoid double-dispatching)
+const managerInProgress = new Set();
 // Cached org config
 let orgConfig = null;
 // Flags to avoid spamming update notices every heartbeat
@@ -61,6 +63,15 @@ async function pollOnce(config) {
                 await handleQueuedTask(task, config);
             }
         }
+        // Handle manager tasks (log analysis, PR review)
+        const managerTasks = response.data.managerTasks;
+        if (managerTasks && managerTasks.length > 0) {
+            for (const mt of managerTasks) {
+                if (!managerInProgress.has(mt.id)) {
+                    await handleManagerTask(mt, config);
+                }
+            }
+        }
     }
     catch (error) {
         const err = error;
@@ -153,9 +164,18 @@ async function handleQueuedTask(task, config) {
         description: task.description,
         jiraIssueKey: task.jiraIssueKey,
         workerModel: task.workerModel,
+        workerProvider: task.workerProvider,
         githubRepo: task.githubRepo,
         scmProvider: task.scmProvider,
         skipManagerReview: task.skipManagerReview,
+        deploymentEnabled: task.deploymentEnabled,
+        improvementEnabled: task.improvementEnabled,
+        qualityGateBypass: task.qualityGateBypass,
+        standardSdkMode: task.standardSdkMode,
+        parentTaskId: task.parentTaskId,
+        taskNotes: task.taskNotes,
+        githubPrUrl: task.githubPrUrl,
+        githubPrNumber: task.githubPrNumber,
         executionPlanV2: task.executionPlanV2,
         jiraFields: task.jiraFields || {},
     };
@@ -164,6 +184,57 @@ async function handleQueuedTask(task, config) {
     // Spawn asynchronously (don't block the poll loop)
     spawnWorker(spawnableTask, config, oc, credentials).catch((err) => console.error(`${ts()} ${chalk.red("✗")} Spawn failed for ${taskLabel}:`, err.message || err));
 }
+/**
+ * Handle a manager task (log analysis or PR review).
+ */
+async function handleManagerTask(task, config) {
+    const taskLabel = chalk.cyan(task.id.slice(0, 8));
+    managerInProgress.add(task.id);
+    // Claim the manager task
+    try {
+        const claimResponse = await api.post("/api/agent/claim-manager", {
+            taskId: task.id,
+            agentId: config.agentId,
+            action: task.managerAction,
+        });
+        if (!claimResponse.data.claimed) {
+            managerInProgress.delete(task.id);
+            return; // Another agent or cloud ECS claimed it
+        }
+        const claimedTask = claimResponse.data.task;
+        const credentials = claimResponse.data.credentials || {};
+        const actionLabel = task.managerAction === "analyze_logs"
+            ? chalk.yellow("LOG ANALYSIS")
+            : chalk.yellow("PR REVIEW");
+        console.log();
+        console.log(`${ts()} ${chalk.magenta("◆ MANAGER")} ${actionLabel} ${taskLabel} ${task.summary.substring(0, 60)}`);
+        const managerTask = {
+            id: task.id,
+            summary: claimedTask?.summary || task.summary,
+            description: claimedTask?.description || task.description,
+            jiraIssueKey: claimedTask?.jiraIssueKey || task.jiraIssueKey,
+            githubRepo: claimedTask?.githubRepo || task.githubRepo,
+            scmProvider: claimedTask?.scmProvider || task.scmProvider,
+            githubPrUrl: claimedTask?.githubPrUrl || task.githubPrUrl,
+            githubPrNumber: claimedTask?.githubPrNumber || task.githubPrNumber,
+            managerAction: task.managerAction,
+        };
+        // Spawn asynchronously (don't block the poll loop)
+        spawnManagerWorker(managerTask, config, credentials)
+            .then(() => {
+            console.log(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${chalk.green("✓")} Manager ${task.managerAction} dispatched`);
+        })
+            .catch((err) => {
+            console.error(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${chalk.red("✗")} Manager spawn failed:`, err.message || err);
+        })
+            .finally(() => managerInProgress.delete(task.id));
+    }
+    catch (err) {
+        managerInProgress.delete(task.id);
+        const error = err;
+        console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Failed to claim manager task:`, error.message || String(err));
+    }
+}
 /**
  * Start the poll loop.
  */

package/dist/spawner.d.ts

@@ -10,17 +10,28 @@
 import type { AgentConfig } from "./config.js";
 export interface SpawnableTask {
     id: string;
+    orgId?: string;
     summary: string;
     description: string | null;
     jiraIssueKey: string | null;
     workerModel: string;
     workerProvider?: string;
+    workerPersona?: string;
     githubRepo: string;
     scmProvider: string;
     skipManagerReview?: boolean;
     executionPlanV2: unknown;
     jiraFields: Record<string, unknown>;
     taskNotes?: string;
+    deploymentEnabled?: boolean;
+    improvementEnabled?: boolean;
+    qualityGateBypass?: boolean;
+    standardSdkMode?: boolean;
+    parentTaskId?: string;
+    githubPrUrl?: string;
+    githubPrNumber?: number;
+    retryCount?: number;
+    pipelineVersion?: string;
 }
 /** Org credentials returned by /api/agent/claim */
 export interface ClaimCredentials {
@@ -33,12 +44,18 @@ export interface ClaimCredentials {
     customerAwsAccessKeyId?: string;
     customerAwsSecretAccessKey?: string;
     customerAwsRegion?: string;
+    customerAwsRoleArn?: string;
+    customerAwsExternalId?: string;
     issueTrackerProvider?: string;
     bitbucketEmail?: string;
+    githubReviewerToken?: string;
+    scmBaseUrl?: string;
+    ollamaContextWindow?: number;
     anthropicApiKey?: string;
     openaiApiKey?: string;
     googleApiKey?: string;
     ollamaBaseUrl?: string;
+    vllmBaseUrl?: string;
 }
 /**
  * Spawn a Docker worker container for a task.
@@ -60,3 +77,34 @@ export declare function stopTask(taskId: string): void;
  * Stop all running containers.
  */
 export declare function stopAll(): Promise<void>;
+/** Manager task returned by the poll endpoint */
+export interface ManagerTask {
+    id: string;
+    summary: string;
+    description: string | null;
+    jiraIssueKey: string | null;
+    githubRepo: string;
+    scmProvider: string;
+    githubPrUrl?: string;
+    githubPrNumber?: number;
+    managerAction: "analyze_logs" | "review_pr";
+}
+/** Credentials for manager tasks (subset of ClaimCredentials) */
+export interface ManagerCredentials {
+    managerProvider?: string;
+    managerModelId?: string;
+    anthropicApiKey?: string;
+    openaiApiKey?: string;
+    googleApiKey?: string;
+    ollamaBaseUrl?: string;
+    jiraBaseUrl?: string;
+    jiraEmail?: string;
+    jiraApiToken?: string;
+    linearApiKey?: string;
+    issueTrackerProvider?: string;
+}
+/**
+ * Spawn a manager Docker container for PR review or log analysis.
+ * Uses the same worker image but overrides the entrypoint to manager-entrypoint.sh.
+ */
+export declare function spawnManagerWorker(task: ManagerTask, config: AgentConfig, credentials?: ManagerCredentials): Promise<void>;

package/dist/spawner.js

@@ -157,26 +157,34 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         EPIC_MODE: "true",
         EXECUTION_MODE: "local",
         TASK_ID: task.id,
-        PARENT_TASK_ID: task.id,
+        ORG_ID: task.orgId || "",
         JIRA_ISSUE_KEY: task.jiraIssueKey || "",
+        JIRA_SUMMARY: task.summary || "",
+        JIRA_DESCRIPTION: task.description || "",
         TASK_SUMMARY: task.summary || "",
         TASK_DESCRIPTION: task.description || "",
+        WORKER_PERSONA: task.workerPersona || "",
+        RETRY_NUMBER: String(task.retryCount ?? 0),
+        TICKET_KEY: task.jiraIssueKey || "",
         // Cloud API — this is what makes remote agent mode work
         API_BASE_URL: config.apiUrl,
         ORG_API_KEY: config.apiKey,
         // SCM configuration
         SCM_PROVIDER: scmProvider,
         SCM_TOKEN: scmToken,
+        SCM_BASE_URL: credentials?.scmBaseUrl || "",
         GITHUB_TOKEN: config.githubToken,
         GH_TOKEN: config.githubToken,
+        GITHUB_REVIEWER_TOKEN: credentials?.githubReviewerToken || "",
         BITBUCKET_TOKEN: config.bitbucketToken,
         BITBUCKET_USERNAME: "x-token-auth",
         GITLAB_TOKEN: config.gitlabToken,
         // Target repository
         TARGET_REPO: task.githubRepo || "",
         GITHUB_REPO: task.githubRepo || "",
-        // Worker model
+        // Worker model (CLAUDE_MODEL is legacy compat for manager entrypoint)
         WORKER_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || "sonnet"),
+        CLAUDE_MODEL: task.workerProvider === "anthropic" ? (task.workerModel || "sonnet") : "sonnet",
         // Jira credentials (from org Secrets Manager via /api/agent/claim)
         JIRA_BASE_URL: credentials?.jiraBaseUrl || "",
         JIRA_EMAIL: credentials?.jiraEmail || "",
@@ -189,13 +197,43 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         AWS_SECRET_ACCESS_KEY: credentials?.customerAwsSecretAccessKey || "",
         AWS_DEFAULT_REGION: credentials?.customerAwsRegion || "",
         AWS_REGION: credentials?.customerAwsRegion || "",
+        // AWS cross-account access (for customer infrastructure deployment)
+        CUSTOMER_AWS_ROLE_ARN: credentials?.customerAwsRoleArn || "",
+        CUSTOMER_AWS_EXTERNAL_ID: credentials?.customerAwsExternalId || "",
+        CUSTOMER_AWS_REGION: credentials?.customerAwsRegion || "",
         // Manager provider and model for tech lead review
         MANAGER_PROVIDER: credentials?.managerProvider || "anthropic",
         MANAGER_MODEL: credentials?.managerModelId || "",
         // Bitbucket email (needed for API calls with API tokens)
         BITBUCKET_EMAIL: credentials?.bitbucketEmail || "",
+        // Workflow control flags (match ECS and local spawner logic)
+        DEPLOYMENT_ENABLED: task.deploymentEnabled || task.parentTaskId ? "true" : "false",
+        PRD_CHILD_TASK: task.parentTaskId ? "true" : "false",
+        IMPROVEMENT_ENABLED: task.improvementEnabled ? "true" : "false",
+        QUALITY_GATE_BYPASS: task.qualityGateBypass ? "true" : "false",
+        STANDARD_SDK_MODE: task.standardSdkMode ? "true" : "false",
+        MAX_REVIEW_REVISIONS: String(orgConfig.maxReviewRevisions ?? 3),
+        CODEBASE_INDEXING_ENABLED: orgConfig.codebaseIndexingEnabled === true ? "true" : "false",
+        // Existing PR info (for deployment-only runs)
+        EXISTING_PR_URL: task.githubPrUrl || "",
+        EXISTING_PR_NUMBER: task.githubPrNumber ? String(task.githubPrNumber) : "",
+        // PRD Orchestration
+        PARENT_TASK_ID: task.parentTaskId || task.id,
+        PARENT_JIRA_KEY: task.jiraIssueKey && /-S\d+$/.test(task.jiraIssueKey)
+            ? task.jiraFields?.parentJiraKey || ""
+            : "",
+        TARGET_BRANCH: task.jiraFields?.targetBranch || "",
+        STORY_BRANCH: task.jiraFields?.storyBranch || "",
         // Task notes from dashboard
         TASK_NOTES: task.taskNotes || "",
+        // File targeting from planning agent (cost-first optimization)
+        TARGET_FILES: JSON.stringify(task.jiraFields?.targetFiles || []),
+        REFERENCE_FILES: JSON.stringify(task.jiraFields?.referenceFiles || []),
+        // V2 Pipeline support
+        PIPELINE_VERSION: task.jiraFields?.pipelineVersion || task.pipelineVersion || "",
+        V2_STEP_INPUT: task.jiraFields?.v2StepInput ? JSON.stringify(task.jiraFields.v2StepInput) : "",
+        // Execution mode for supervised/autonomous
+        EXECUTION_MODE_SETTING: task.jiraFields?.executionMode || "autonomous",
         // AI provider configuration
         ANTHROPIC_API_KEY: claudeConfigDir ? "" : (credentials?.anthropicApiKey || process.env.ANTHROPIC_API_KEY || ""),
         WORKER_PROVIDER: task.workerProvider || "anthropic",
@@ -203,6 +241,8 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         GOOGLE_API_KEY: credentials?.googleApiKey || "",
         GOOGLE_GENERATIVE_AI_API_KEY: credentials?.googleApiKey || "",
         OLLAMA_HOST: credentials?.ollamaBaseUrl || "",
+        OLLAMA_CONTEXT_WINDOW: credentials?.ollamaContextWindow ? String(credentials.ollamaContextWindow) : "",
+        VLLM_BASE_URL: credentials?.vllmBaseUrl || "",
         // Resilience settings from org config
         BLOCKER_MAX_AUTO_RETRIES: String(orgConfig.blockerMaxAutoRetries ?? 3),
         BLOCKER_AUTO_RETRY_ENABLED: orgConfig.blockerAutoRetryEnabled !== false ? "true" : "false",
@@ -316,3 +356,118 @@ export async function stopAll() {
     }
     activeContainers.clear();
 }
+/**
+ * Spawn a manager Docker container for PR review or log analysis.
+ * Uses the same worker image but overrides the entrypoint to manager-entrypoint.sh.
+ */
+export async function spawnManagerWorker(task, config, credentials) {
+    const taskLabel = chalk.cyan(task.id.slice(0, 8));
+    // Check if already running a manager for this task
+    const managerKey = `manager-${task.id}`;
+    if (activeContainers.has(managerKey)) {
+        return;
+    }
+    const containerName = `wm-manager-${task.id.slice(0, 8)}-${Date.now()}`;
+    // Mount Claude credentials
+    const claudeConfigDir = findClaudeConfigDir();
+    const dockerArgs = [
+        "run", "--rm",
+        "--name", containerName,
+        "--memory=4g",
+        "--cpus=2",
+    ];
+    if (claudeConfigDir) {
+        const dockerClaudeDir = toDockerPath(claudeConfigDir);
+        dockerArgs.push("-v", `${dockerClaudeDir}:/home/worker/.claude`);
+    }
+    // Manager-specific env vars (match ECS runManagerTask)
+    const scmProvider = (task.scmProvider || "github");
+    const scmToken = getScmToken(scmProvider, config);
+    const envVars = {
+        NODE_OPTIONS: "--max-old-space-size=3072",
+        TASK_ID: task.id,
+        MANAGER_ACTION: task.managerAction,
+        JIRA_ISSUE_KEY: task.jiraIssueKey || "",
+        JIRA_SUMMARY: task.summary || "",
+        JIRA_DESCRIPTION: task.description || "",
+        GITHUB_REPO: task.githubRepo || "",
+        PR_URL: task.githubPrUrl || "",
+        PR_NUMBER: task.githubPrNumber ? String(task.githubPrNumber) : "",
+        // Cloud API
+        API_BASE_URL: config.apiUrl,
+        ORG_API_KEY: config.apiKey,
+        // SCM configuration
+        SCM_PROVIDER: scmProvider,
+        SCM_TOKEN: scmToken,
+        GITHUB_TOKEN: config.githubToken,
+        GH_TOKEN: config.githubToken,
+        BITBUCKET_TOKEN: config.bitbucketToken,
+        BITBUCKET_USERNAME: "x-token-auth",
+        GITLAB_TOKEN: config.gitlabToken,
+        // Manager provider and model
+        MANAGER_PROVIDER: credentials?.managerProvider || "anthropic",
+        MANAGER_MODEL: credentials?.managerModelId || "",
+        // AI provider API keys
+        ANTHROPIC_API_KEY: claudeConfigDir ? "" : (credentials?.anthropicApiKey || process.env.ANTHROPIC_API_KEY || ""),
+        OPENAI_API_KEY: credentials?.openaiApiKey || "",
+        GOOGLE_API_KEY: credentials?.googleApiKey || "",
+        // Jira credentials
+        JIRA_BASE_URL: credentials?.jiraBaseUrl || "",
+        JIRA_EMAIL: credentials?.jiraEmail || "",
+        JIRA_API_TOKEN: credentials?.jiraApiToken || "",
+        TICKET_SYSTEM: credentials?.issueTrackerProvider || "jira",
+        LINEAR_API_KEY: credentials?.linearApiKey || "",
+    };
+    // Build -e args, filtering empty values
+    for (const [k, v] of Object.entries(envVars)) {
+        if (v !== "") {
+            dockerArgs.push("-e", `${k}=${v}`);
+        }
+    }
+    // Worker image with manager entrypoint override
+    const workerImage = config.workerImage || "public.ecr.aws/a7k5r0v0/workermill-worker:latest";
+    dockerArgs.push("--entrypoint", "/bin/bash");
+    dockerArgs.push(workerImage);
+    dockerArgs.push("/app/manager-entrypoint.sh");
+    console.log(`${ts()} ${taskLabel} ${chalk.magenta("◆ MANAGER")} Starting ${task.managerAction} container ${chalk.yellow(containerName)}`);
+    const proc = spawn("docker", dockerArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    if (!proc.pid) {
+        console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Failed to spawn manager container`);
+        return;
+    }
+    const container = {
+        taskId: managerKey,
+        containerName,
+        process: proc,
+        startedAt: new Date(),
+        status: "running",
+    };
+    activeContainers.set(managerKey, container);
+    proc.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            console.log(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${chalk.dim(line)}`);
+        }
+    });
+    proc.stderr?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            console.log(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${chalk.red(line)}`);
+        }
+    });
+    proc.on("exit", (code) => {
+        container.status = code === 0 ? "completed" : "failed";
+        const duration = Math.round((Date.now() - container.startedAt.getTime()) / 1000);
+        const icon = code === 0 ? chalk.green("✓") : chalk.red("✗");
+        const status = code === 0 ? chalk.green("completed") : chalk.red(`failed (exit ${code})`);
+        console.log(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${icon} Manager ${task.managerAction} ${status} ${chalk.dim(`(${duration}s)`)}`);
+        setTimeout(() => activeContainers.delete(managerKey), 60_000);
+    });
+    proc.on("error", (err) => {
+        container.status = "failed";
+        console.error(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${chalk.red("✗")} Container error: ${err.message}`);
+    });
+}

package/package.json

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