@workermill/agent 0.1.0 → 0.1.2

package/dist/planner.js

@@ -51,14 +51,22 @@ async function postProgress(taskId, phase, elapsedSeconds, detail, charsGenerate
         // Fire and forget
     }
 }
+/** Consistent prefix matching local workermill dashboard format */
+const PREFIX = "[🗺️ planning_agent 🤖]";
+/** Format elapsed seconds as human-readable string (e.g. "28s", "1m 25s") */
+function formatElapsed(seconds) {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+}
 function phaseLabel(phase, elapsed) {
     switch (phase) {
-        case "initializing": return "Starting planning agent...";
-        case "reading_repo": return "Reading repository structure...";
-        case "analyzing": return "Analyzing requirements...";
-        case "generating_plan": return `Generating execution plan... (${elapsed}s)`;
-        case "validating": return "Validating plan...";
-        case "complete": return "Planning complete";
+        case "initializing": return `${PREFIX} Starting planning agent...`;
+        case "reading_repo": return `${PREFIX} Reading repository structure...`;
+        case "analyzing": return `${PREFIX} Analyzing requirements...`;
+        case "generating_plan": return `${PREFIX} Planning in progress — analyzing requirements and decomposing into steps (${formatElapsed(elapsed)} elapsed)`;
+        case "validating": return `${PREFIX} Validating plan...`;
+        case "complete": return `${PREFIX} Planning complete`;
     }
 }
 /**
@@ -119,7 +127,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             // Periodic progress during generation
             if (currentPhase === "generating_plan" && elapsed - lastProgressLogAt >= 30) {
                 lastProgressLogAt = elapsed;
-                const msg = `Generating execution plan... (${elapsed}s, ${charsReceived} chars, ${toolCallCount} tool calls)`;
+                const msg = `${PREFIX} Planning in progress — analyzing requirements and decomposing into steps (${formatElapsed(elapsed)} elapsed)`;
                 postLog(taskId, msg);
                 console.log(`${ts()} ${taskLabel} ${chalk.dim(msg)}`);
             }
@@ -217,7 +225,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
 export async function planTask(task, config) {
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
     console.log(`${ts()} ${taskLabel} Fetching planning prompt...`);
-    await postLog(task.id, "Fetching planning prompt from cloud API...");
+    await postLog(task.id, `${PREFIX} Fetching planning prompt from cloud API...`);
     // 1. Fetch the assembled planning prompt from the cloud API
     const promptResponse = await api.get("/api/agent/planning-prompt", {
         params: { taskId: task.id },
@@ -225,7 +233,7 @@ export async function planTask(task, config) {
     const { prompt, model } = promptResponse.data;
     const cliModel = model || "sonnet";
     console.log(`${ts()} ${taskLabel} Running Claude CLI ${chalk.dim(`(model: ${chalk.yellow(cliModel)})`)}`);
-    await postLog(task.id, `Starting planning agent (model: ${cliModel})...`);
+    await postLog(task.id, `${PREFIX} Starting planning agent using anthropic/${cliModel}`);
     // 2. Run Claude CLI asynchronously with progress logging
     const claudePath = process.env.CLAUDE_CLI_PATH || findClaudePath() || "claude";
     const cleanEnv = { ...process.env };
@@ -239,12 +247,12 @@ export async function planTask(task, config) {
         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, `Planning agent failed after ${elapsed}s: ${errMsg.substring(0, 200)}`, "error", "error");
+        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)`)}`);
-    await postLog(task.id, `Planning complete (${elapsed}s, ${rawOutput.length} chars). Validating plan...`);
+    await postLog(task.id, `${PREFIX} Planning complete (${formatElapsed(elapsed)}). Validating plan...`);
     // 3. Post raw output back to cloud API for validation
     try {
         const result = await api.post("/api/agent/plan-result", {
@@ -254,7 +262,7 @@ export async function planTask(task, config) {
         });
         const storyCount = result.data.storyCount;
         console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Plan validated: ${chalk.bold(storyCount)} stories → ${chalk.green("queued")}`);
-        await postLog(task.id, `Plan validated: ${storyCount} stories. Task queued for execution.`);
+        await postLog(task.id, `${PREFIX} Plan validated: ${storyCount} stories. Task queued for execution.`);
         await postProgress(task.id, "complete", elapsed, "Planning complete", 0, 0);
         return true;
     }
@@ -262,7 +270,7 @@ export async function planTask(task, config) {
         const err = error;
         const detail = err.response?.data?.detail || String(error);
         console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Validation failed: ${detail.substring(0, 100)}`);
-        await postLog(task.id, `Plan validation failed: ${detail.substring(0, 200)}`, "error", "error");
+        await postLog(task.id, `${PREFIX} Plan validation failed: ${detail.substring(0, 200)}`, "error", "error");
         return false;
     }
 }

package/dist/poller.js

@@ -149,8 +149,10 @@ async function handleQueuedTask(task, config) {
         executionPlanV2: task.executionPlanV2,
         jiraFields: task.jiraFields || {},
     };
+    // Pass org credentials from the claim response to the container
+    const credentials = claimData.credentials;
     // Spawn asynchronously (don't block the poll loop)
-    spawnWorker(spawnableTask, config, oc).catch((err) => console.error(`${ts()} ${chalk.red("✗")} Spawn failed for ${taskLabel}:`, err.message || err));
+    spawnWorker(spawnableTask, config, oc, credentials).catch((err) => console.error(`${ts()} ${chalk.red("✗")} Spawn failed for ${taskLabel}:`, err.message || err));
 }
 /**
  * Start the poll loop.

package/dist/spawner.d.ts

@@ -19,11 +19,26 @@ export interface SpawnableTask {
     skipManagerReview?: boolean;
     executionPlanV2: unknown;
     jiraFields: Record<string, unknown>;
+    taskNotes?: string;
+}
+/** Org credentials returned by /api/agent/claim */
+export interface ClaimCredentials {
+    jiraBaseUrl?: string;
+    jiraEmail?: string;
+    jiraApiToken?: string;
+    linearApiKey?: string;
+    managerProvider?: string;
+    managerModelId?: string;
+    customerAwsAccessKeyId?: string;
+    customerAwsSecretAccessKey?: string;
+    customerAwsRegion?: string;
+    issueTrackerProvider?: string;
+    bitbucketEmail?: string;
 }
 /**
  * Spawn a Docker worker container for a task.
  */
-export declare function spawnWorker(task: SpawnableTask, config: AgentConfig, orgConfig: Record<string, unknown>): Promise<void>;
+export declare function spawnWorker(task: SpawnableTask, config: AgentConfig, orgConfig: Record<string, unknown>, credentials?: ClaimCredentials): Promise<void>;
 /**
  * Get count of actively running containers.
  */

package/dist/spawner.js

@@ -104,7 +104,7 @@ function hasSelfReviewLabel(task) {
 /**
  * Spawn a Docker worker container for a task.
  */
-export async function spawnWorker(task, config, orgConfig) {
+export async function spawnWorker(task, config, orgConfig, credentials) {
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
     if (activeContainers.has(task.id)) {
         console.log(`${ts()} ${taskLabel} ${chalk.dim("Already running, skipping")}`);
@@ -174,6 +174,25 @@ export async function spawnWorker(task, config, orgConfig) {
         GITHUB_REPO: task.githubRepo || "",
         // Worker model
         WORKER_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || "sonnet"),
+        // Jira credentials (from org Secrets Manager via /api/agent/claim)
+        JIRA_BASE_URL: credentials?.jiraBaseUrl || "",
+        JIRA_EMAIL: credentials?.jiraEmail || "",
+        JIRA_API_TOKEN: credentials?.jiraApiToken || "",
+        // Issue tracker system (jira, linear, github-issues)
+        TICKET_SYSTEM: credentials?.issueTrackerProvider || "jira",
+        LINEAR_API_KEY: credentials?.linearApiKey || "",
+        // AWS credentials (from org Secrets Manager for workers that deploy infrastructure)
+        AWS_ACCESS_KEY_ID: credentials?.customerAwsAccessKeyId || "",
+        AWS_SECRET_ACCESS_KEY: credentials?.customerAwsSecretAccessKey || "",
+        AWS_DEFAULT_REGION: credentials?.customerAwsRegion || "",
+        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 || "",
+        // Task notes from dashboard
+        TASK_NOTES: task.taskNotes || "",
         // Anthropic API key (if available)
         ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
         // Resilience settings from org config

package/package.json

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