@elizaos/plugin-agent-orchestrator 0.3.3 → 0.3.6

package/dist/index.js

@@ -490,6 +490,17 @@ function toDecisionHistory(taskCtx) {
     reasoning: d.reasoning
   }));
 }
+async function drainPendingTurnComplete(ctx, sessionId) {
+  const pendingData = ctx.pendingTurnComplete.get(sessionId);
+  if (!pendingData)
+    return;
+  ctx.pendingTurnComplete.delete(sessionId);
+  const taskCtx = ctx.tasks.get(sessionId);
+  if (!taskCtx || taskCtx.status !== "active")
+    return;
+  ctx.log(`Draining buffered turn-complete for "${taskCtx.label}"`);
+  await handleTurnComplete(ctx, sessionId, taskCtx, pendingData);
+}
 function formatDecisionResponse(decision) {
   if (decision.action !== "respond")
     return;
@@ -721,7 +732,8 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
 }
 async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
   if (ctx.inFlightDecisions.has(sessionId)) {
-    ctx.log(`Skipping turn-complete assessment for ${sessionId} (in-flight)`);
+    ctx.log(`Buffering turn-complete for ${sessionId} (in-flight decision running)`);
+    ctx.pendingTurnComplete.set(sessionId, data);
     return;
   }
   ctx.inFlightDecisions.add(sessionId);
@@ -914,6 +926,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
     await executeDecision(ctx, sessionId, decision);
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
+    await drainPendingTurnComplete(ctx, sessionId);
   }
 }
 async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recentOutput, promptType) {
@@ -989,6 +1002,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
     });
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
+    await drainPendingTurnComplete(ctx, sessionId);
   }
 }
 var MAX_AUTO_RESPONSES = 10;
@@ -2495,11 +2509,15 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
       }, VERIFY_DELAY_MS);
     }
   };
+  const READY_TIMEOUT_MS = 30000;
   let taskSent = false;
+  let readyTimeout;
   const sendTask = () => {
     if (taskSent)
       return;
     taskSent = true;
+    if (readyTimeout)
+      clearTimeout(readyTimeout);
     setTimeout(() => sendTaskWithRetry(0), settleMs);
     if (ctx.usingBunWorker) {
       ctx.manager.removeListener("session_ready", onReady);
@@ -2520,6 +2538,12 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
     } else {
       ctx.manager.on("session_ready", onReady);
     }
+    readyTimeout = setTimeout(() => {
+      if (!taskSent) {
+        ctx.log(`Session ${sid} — ready event not received within ${READY_TIMEOUT_MS}ms, forcing task delivery`);
+        sendTask();
+      }
+    }, READY_TIMEOUT_MS);
   }
 }
 function buildSpawnConfig(sessionId, options, workdir) {
@@ -2744,6 +2768,120 @@ async function classifyStallOutput(ctx) {
     return null;
   }
 }
+function buildCombinedClassifyDecidePrompt(agentType, sessionId, output, taskContext, decisionHistory) {
+  const historySection = decisionHistory.length > 0 ? `
+Previous decisions for this session:
+${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
+`)}
+` : "";
+  return `You are Milady, an AI orchestrator managing coding agent sessions. A ${agentType} coding agent (session: ${sessionId}) appears to have stalled — ` + `it has stopped producing output while in a busy state.
+
+Original task: "${taskContext.originalTask}"
+Working directory: ${taskContext.workdir}
+Repository: ${taskContext.repo ?? "none (scratch directory)"}
+` + historySection + `
+Here is the recent terminal output:
+---
+${output.slice(-1500)}
+---
+
+Classify what's happening AND decide how to respond. Read the output carefully.
+
+Classification states:
+
+` + `1. "task_complete" — The agent FINISHED its task and returned to its idle prompt. ` + `Strong indicators: a summary of completed work, timing info, ` + `or the agent's main prompt symbol (❯) appearing AFTER completion output.
+
+` + `2. "waiting_for_input" — The agent is MID-TASK and blocked on a specific question or permission prompt. ` + `Examples: Y/n confirmation, file permission dialogs, tool approval prompts, interactive menus.
+
+` + `3. "still_working" — The agent is actively processing (API call, compilation, thinking). ` + `No prompt or completion summary visible.
+
+` + `4. "error" — The agent hit an error state (crash, unrecoverable error, stack trace).
+
+` + `5. "tool_running" — The agent is using an external tool (browser automation, MCP tool, etc.).
+
+` + `If "waiting_for_input", you must also decide how to respond. Guidelines:
+- IMPORTANT: If the prompt asks to approve access to files or directories OUTSIDE the working directory (${taskContext.workdir}), DECLINE the request. Respond with "n" and tell the agent: "That path is outside your workspace. Use ${taskContext.workdir} instead."
+- For tool approval prompts (file writes, shell commands), respond "y" or use "keys:enter".
+- For Y/n confirmations that align with the original task, respond "y".
+- For TUI menus, use "keys:enter" for default or "keys:down,enter" for non-default.
+- If the prompt asks for information NOT in the original task, set suggestedResponse to null (this will escalate to the human).
+- If a PR was just created, respond to review & verify test plan items before completing.
+
+Respond with ONLY a JSON object:
+{"state": "...", "prompt": "...", "suggestedResponse": "..."}`;
+}
+async function classifyAndDecideForCoordinator(ctx) {
+  const {
+    sessionId,
+    recentOutput,
+    agentType,
+    buffers,
+    traceEntries,
+    runtime,
+    manager,
+    metricsTracker,
+    taskContext,
+    decisionHistory = [],
+    log
+  } = ctx;
+  metricsTracker.incrementStalls(agentType);
+  let effectiveOutput = recentOutput;
+  if (!recentOutput || recentOutput.trim().length < 200) {
+    const ourBuffer = buffers.get(sessionId);
+    if (ourBuffer && ourBuffer.length > 0) {
+      const rawTail = ourBuffer.slice(-100).join(`
+`);
+      const stripped = stripAnsi(rawTail);
+      if (stripped.length > effectiveOutput.length) {
+        effectiveOutput = stripped;
+        log(`Using own buffer for combined classify+decide (${effectiveOutput.length} chars after stripping, pty-manager had ${recentOutput.length})`);
+      }
+    }
+  }
+  const systemPrompt = buildCombinedClassifyDecidePrompt(agentType, sessionId, effectiveOutput, taskContext, decisionHistory);
+  if (ctx.debugSnapshots) {
+    await writeStallSnapshot(sessionId, agentType, recentOutput, effectiveOutput, buffers, traceEntries, log);
+  }
+  try {
+    log(`Stall detected for coordinator-managed ${sessionId}, combined classify+decide...`);
+    const result = await runtime.useModel(ModelType.TEXT_SMALL, {
+      prompt: systemPrompt
+    });
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      log(`Combined classify+decide: no JSON in LLM response`);
+      return null;
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    const validStates = [
+      "waiting_for_input",
+      "still_working",
+      "task_complete",
+      "error",
+      "tool_running"
+    ];
+    if (!validStates.includes(parsed.state)) {
+      log(`Combined classify+decide: invalid state "${parsed.state}"`);
+      return null;
+    }
+    const mappedState = parsed.state === "tool_running" ? "still_working" : parsed.state;
+    const classification = {
+      state: mappedState,
+      prompt: parsed.prompt,
+      suggestedResponse: parsed.suggestedResponse
+    };
+    log(`Combined classify+decide for ${sessionId}: ${classification.state}${classification.suggestedResponse ? ` → "${classification.suggestedResponse}"` : ""}`);
+    if (classification.state === "task_complete") {
+      const session = manager?.get(sessionId);
+      const durationMs = session?.startedAt ? Date.now() - new Date(session.startedAt).getTime() : 0;
+      metricsTracker.recordCompletion(agentType, "classifier", durationMs);
+    }
+    return classification;
+  } catch (err) {
+    log(`Combined classify+decide failed: ${err}`);
+    return null;
+  }
+}
 
 // src/services/swarm-coordinator.ts
 init_ansi_utils();
@@ -2937,6 +3075,7 @@ class SwarmCoordinator {
   supervisionLevel = "autonomous";
   pendingDecisions = new Map;
   inFlightDecisions = new Set;
+  pendingTurnComplete = new Map;
   chatCallback = null;
   wsBroadcast = null;
   agentDecisionCb = null;
@@ -3004,6 +3143,7 @@ class SwarmCoordinator {
     this.tasks.clear();
     this.pendingDecisions.clear();
     this.inFlightDecisions.clear();
+    this.pendingTurnComplete.clear();
     this.unregisteredBuffer.clear();
     this.lastSeenOutput.clear();
     this.lastToolNotification.clear();
@@ -3698,6 +3838,38 @@ class PTYService {
   async classifyStall(sessionId, recentOutput) {
     const meta = this.sessionMetadata.get(sessionId);
     const agentType = meta?.agentType ?? "unknown";
+    if (meta?.coordinatorManaged && this.coordinator?.getSupervisionLevel() === "autonomous") {
+      const taskCtx = this.coordinator.getTaskContext(sessionId);
+      if (taskCtx) {
+        return classifyAndDecideForCoordinator({
+          sessionId,
+          recentOutput,
+          agentType,
+          buffers: this.sessionOutputBuffers,
+          traceEntries: this.traceEntries,
+          runtime: this.runtime,
+          manager: this.manager,
+          metricsTracker: this.metricsTracker,
+          debugSnapshots: this.serviceConfig.debug === true,
+          log: (msg) => this.log(msg),
+          taskContext: {
+            sessionId: taskCtx.sessionId,
+            agentType: taskCtx.agentType,
+            label: taskCtx.label,
+            originalTask: taskCtx.originalTask,
+            workdir: taskCtx.workdir,
+            repo: taskCtx.repo
+          },
+          decisionHistory: taskCtx.decisions.filter((d) => d.decision !== "auto_resolved").slice(-5).map((d) => ({
+            event: d.event,
+            promptText: d.promptText,
+            action: d.decision,
+            response: d.response,
+            reasoning: d.reasoning
+          }))
+        });
+      }
+    }
     const classification = await classifyStallOutput({
       sessionId,
       recentOutput,
@@ -4174,7 +4346,7 @@ async function handleMultiAgent(ctx, agentsParam) {
     let specRequestedType = rawAgentType;
     let specTask = spec;
     const colonIdx = spec.indexOf(":");
-    if (colonIdx > 0 && colonIdx < 20) {
+    if (ctx.agentSelectionStrategy !== "fixed" && colonIdx > 0 && colonIdx < 20) {
       const prefix = spec.slice(0, colonIdx).trim().toLowerCase();
       const knownTypes = [
         "claude",
@@ -4199,6 +4371,28 @@ async function handleMultiAgent(ctx, agentsParam) {
         specAgentType = normalizeAgentType(prefix);
         specTask = spec.slice(colonIdx + 1).trim();
       }
+    } else if (ctx.agentSelectionStrategy === "fixed" && colonIdx > 0 && colonIdx < 20) {
+      const prefix = spec.slice(0, colonIdx).trim().toLowerCase();
+      const knownTypes = [
+        "claude",
+        "claude-code",
+        "claudecode",
+        "codex",
+        "openai",
+        "gemini",
+        "google",
+        "aider",
+        "pi",
+        "pi-ai",
+        "piai",
+        "pi-coding-agent",
+        "picodingagent",
+        "shell",
+        "bash"
+      ];
+      if (knownTypes.includes(prefix)) {
+        specTask = spec.slice(colonIdx + 1).trim();
+      }
     }
     const specLabel = explicitLabel ? `${explicitLabel}-${i + 1}` : generateLabel(repo, specTask);
     try {
@@ -4573,6 +4767,7 @@ var startCodingTaskAction = {
       repo,
       defaultAgentType,
       rawAgentType,
+      agentSelectionStrategy: ptyService.agentSelectionStrategy,
       memoryContent,
       approvalPreset,
       explicitLabel
@@ -6350,5 +6545,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=A1B0DE07402807E864756E2164756E21
+//# debugId=D911125D768F397664756E2164756E21
 //# sourceMappingURL=index.js.map