@elizaos/plugin-agent-orchestrator 0.2.0 → 0.3.0

package/dist/index.js

@@ -114,11 +114,31 @@ function buildTurnCompletePrompt(taskCtx, turnOutput, decisionHistory) {
 
 ` + `Guidelines:\n` + `- BEFORE choosing "complete", enumerate each objective from the original task and verify ` + `evidence in the output. If ANY objective lacks evidence, use "respond" with the missing work.\n` + `- A PR being created does NOT mean the task is done \u2014 check that the PR covers ALL requested changes.
 ` + `- If the task mentions multiple features/fixes, verify EACH one is addressed, not just the first.\n` + `- If the agent only analyzed code or read files, it hasn't done the actual work yet \u2014 send a follow-up.
-` + `- If the agent wrote code but didn't test it and testing seems appropriate, ask it to run tests.\n` + `- If the output shows errors or failed tests, send a follow-up to fix them.\n` + `- IMPORTANT: If the working directory is a git repository clone (not a scratch dir), the agent ` + `MUST commit its changes, push them, and create a pull request before the task can be "complete". ` + `If the output only shows code edits with no git commit or PR, respond with "Now commit your changes, push, and create a pull request".\n` + `- CRITICAL: Creating a PR is NEVER the final step. After you see "Created pull request" or a PR URL ` + `in the output, you MUST respond with "Review your PR, run each test plan item to verify it works, ` + `update the PR to check off each item, then confirm all items pass". NEVER mark as "complete" on the ` + `same turn that a PR was created \u2014 always send this follow-up first.
-` + `- Only mark as "complete" AFTER the agent has confirmed it verified the test plan items ` + `(look for output like "all items pass", "verified", "checked off", or similar confirmation).\n` + `- Keep follow-up instructions concise and specific.\n` + `- Default to "respond" \u2014 only use "complete" when you're certain ALL work is done.
+` + `- If the agent wrote code but didn't test it and testing seems appropriate, ask it to run tests.\n` + `- If the output shows errors or failed tests, send a follow-up to fix them.\n` + `- IMPORTANT: If the working directory is a git repository clone (not a scratch dir), the agent ` + `MUST commit its changes, push them, and create a pull request before the task can be "complete". ` + `If the output only shows code edits with no git commit or PR, respond with "Now commit your changes, push, and create a pull request".\n` + `- IMPORTANT: Creating a PR is NOT the final step. If this is the turn where the PR was created ` + `(i.e. "Created pull request" or a PR URL appears for the FIRST time and no previous decision ` + `already sent a review follow-up), respond with "Review your PR, run each test plan item to verify ` + `it works, update the PR to check off each item, then confirm all items pass".\n` + `- If a previous decision ALREADY sent a review/verification follow-up (check the decision history), ` + `and the agent has now responded with its review results, you MAY mark "complete" if the agent ` + `indicates the work is done (e.g. "Done", "verified", "all checks pass", "Here's what I did", ` + `or a clear summary of completed work). Do NOT require exact phrases \u2014 use judgment.
+` + `- Keep follow-up instructions concise and specific.\n` + `- Default to "respond" \u2014 only use "complete" when you're certain ALL work is done.
 
 ` + `Respond with ONLY a JSON object:\n` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
 }
+function buildBlockedEventMessage(taskCtx, promptText, recentOutput, decisionHistory) {
+  const historySection = decisionHistory.length > 0 ? `\nPrevious decisions:\n${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" \u2192 ${d.action}${d.response ? ` ("${d.response}")` : ""} \u2014 ${d.reasoning}`).join("\n")}\n` : "";
+  return `[Coding Agent Event] A ${taskCtx.agentType} agent ("${taskCtx.label}") is blocked and waiting for input.\n\n` + `Task: "${taskCtx.originalTask}"\n` + `Workdir: ${taskCtx.workdir}\n` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}\n` + historySection + `\nRecent terminal output:\n---\n${recentOutput.slice(-3000)}\n---\n\n` + `Blocking prompt: "${promptText}"\n\n` + `Decide how to handle this. Options:\n` + `- "respond" \u2014 send text or keys to unblock the agent
+` + `- "complete" \u2014 the task is fully done
+` + `- "escalate" \u2014 you need the user's input
+` + `- "ignore" \u2014 not actually blocking
+
+` + `Guidelines:\n` + `- For tool approvals / Y/n that align with the task, respond "y" or keys:["enter"].\n` + `- If the prompt asks for info NOT in the original task, escalate.\n` + `- Decline access to paths outside ${taskCtx.workdir}.\n` + `- If a PR was just created, respond to review & verify test plan items before completing.\n` + `- When in doubt, escalate.\n\n` + `Include a JSON action block at the end of your response:\n` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}\n` + "```";
+}
+function buildTurnCompleteEventMessage(taskCtx, turnOutput, decisionHistory) {
+  const historySection = decisionHistory.length > 0 ? `\nPrevious decisions:\n${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" \u2192 ${d.action}${d.response ? ` ("${d.response}")` : ""} \u2014 ${d.reasoning}`).join("\n")}\n` : "";
+  return `[Coding Agent Event] A ${taskCtx.agentType} agent ("${taskCtx.label}") just finished a turn and is idle.\n\n` + `Task: "${taskCtx.originalTask}"\n` + `Workdir: ${taskCtx.workdir}\n` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}\n` + historySection + `\nTurn output:\n---\n${turnOutput.slice(-3000)}\n---\n\n` + `Decide if the overall task is done or if the agent needs more work.\n\n` + `Options:\n` + `- "respond" \u2014 send a follow-up instruction (DEFAULT for intermediate steps)
+` + `- "complete" \u2014 ALL task objectives met (code written, committed, PR created & verified)
+` + `- "escalate" \u2014 something looks wrong, ask the user
+` + `- "ignore" \u2014 should not normally be used here
+
+` + `Guidelines:\n` + `- Verify evidence for EVERY objective before using "complete".\n` + `- If code was written but not committed/pushed/PR'd, respond with next step.\n` + `- If a PR was just created, respond to review & verify test plan items.\n` + `- Default to "respond" \u2014 only "complete" when certain ALL work is done.
+
+` + `Include a JSON action block at the end of your response:\n` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}\n` + "```";
+}
 function parseCoordinationResponse(llmOutput) {
   const jsonMatch = llmOutput.match(/\{[\s\S]*\}/);
   if (!jsonMatch)
@@ -148,6 +168,123 @@ function parseCoordinationResponse(llmOutput) {
   }
 }
 
+// src/services/swarm-event-triage.ts
+import {ModelType as ModelType2} from "@elizaos/core";
+function classifyByHeuristic(ctx) {
+  if (ctx.promptType) {
+    if (ROUTINE_PROMPT_TYPES.has(ctx.promptType))
+      return "routine";
+    if (CREATIVE_PROMPT_TYPES.has(ctx.promptType))
+      return "creative";
+  }
+  if (ctx.eventType === "blocked" && ctx.promptText) {
+    const hasRoutine = ROUTINE_PATTERNS.some((r) => r.test(ctx.promptText));
+    const hasCreative = CREATIVE_PATTERNS.some((r) => r.test(ctx.promptText));
+    if (hasRoutine && !hasCreative)
+      return "routine";
+    if (hasCreative && !hasRoutine)
+      return "creative";
+    if (hasCreative)
+      return "creative";
+  }
+  if (ctx.eventType === "turn_complete" && ctx.recentOutput) {
+    const isTerminal = TERMINAL_OUTPUT_PATTERNS.some((r) => r.test(ctx.recentOutput));
+    const isIntermediate = INTERMEDIATE_OUTPUT_PATTERNS.some((r) => r.test(ctx.recentOutput));
+    if (isTerminal || isIntermediate)
+      return "routine";
+  }
+  return null;
+}
+function buildTriagePrompt(ctx) {
+  const eventDesc = ctx.eventType === "blocked" ? `BLOCKED prompt: "${ctx.promptText.slice(0, 300)}"` : `TURN COMPLETE. Recent output:\n${(ctx.recentOutput ?? "").slice(-500)}`;
+  return `Classify this coding agent event as "routine" or "creative".\n\n` + `Task: ${ctx.originalTask.slice(0, 200)}\n` + `Event: ${eventDesc}\n\n` + `"routine" = simple approval, permission, config, yes/no, tool consent, obvious pass/fail.\n` + `"creative" = needs task context, error recovery, design choice, ambiguous situation, approach selection.\n\n` + `Respond with ONLY a JSON object: {"tier": "routine"} or {"tier": "creative"}`;
+}
+function parseTriageResponse(llmOutput) {
+  const matches = llmOutput.matchAll(/\{[\s\S]*?\}/g);
+  for (const match of matches) {
+    try {
+      const parsed = JSON.parse(match[0]);
+      if (parsed.tier === "routine" || parsed.tier === "creative") {
+        return parsed.tier;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function classifyEventTier(runtime, ctx, log) {
+  const heuristicResult = classifyByHeuristic(ctx);
+  if (heuristicResult) {
+    log(`Triage: heuristic \u2192 ${heuristicResult}`);
+    return heuristicResult;
+  }
+  try {
+    const prompt = buildTriagePrompt(ctx);
+    const result = await runtime.useModel(ModelType2.TEXT_SMALL, { prompt });
+    const tier = parseTriageResponse(result);
+    if (tier) {
+      log(`Triage: LLM \u2192 ${tier}`);
+      return tier;
+    }
+    log(`Triage: LLM returned unparseable response \u2014 defaulting to creative`);
+  } catch (err) {
+    log(`Triage: LLM classifier failed: ${err} \u2014 defaulting to creative`);
+  }
+  return "creative";
+}
+var ROUTINE_PROMPT_TYPES, CREATIVE_PROMPT_TYPES, ROUTINE_PATTERNS, CREATIVE_PATTERNS, TERMINAL_OUTPUT_PATTERNS, INTERMEDIATE_OUTPUT_PATTERNS;
+var init_swarm_event_triage = __esm(() => {
+  ROUTINE_PROMPT_TYPES = new Set([
+    "permission",
+    "config",
+    "tos",
+    "tool_wait"
+  ]);
+  CREATIVE_PROMPT_TYPES = new Set(["project_select", "model_select"]);
+  ROUTINE_PATTERNS = [
+    /\bAllow\s+tool\b/i,
+    /\(Y\/n\)/,
+    /\(y\/N\)/,
+    /\bTrust\s+(this\s+)?directory\b/i,
+    /\bProceed\?/i,
+    /\boverwrite\?/i,
+    /\bDo you trust\b/i,
+    /\bAllow access\b/i,
+    /\bGrant permission\b/i,
+    /\bAccept\?/i,
+    /\bContinue\?/i,
+    /\bPermit\b.*\?/i,
+    /\bApprove\b.*\?/i
+  ];
+  CREATIVE_PATTERNS = [
+    /\bWhich approach\b/i,
+    /\bHow should\b/i,
+    /\btests? failing\b/i,
+    /\bchoose between\b/i,
+    /\bpick (one|a|an)\b/i,
+    /\bWhat do you (want|think)\b/i,
+    /\berror recover/i,
+    /\bfailed with\b/i,
+    /\bcompilation error/i,
+    /\bbuild failed\b/i,
+    /\btype error/i,
+    /\bmerge conflict/i
+  ];
+  TERMINAL_OUTPUT_PATTERNS = [
+    /All \d+ tests? pass/i,
+    /Tests?:\s+\d+ passed/i,
+    /✓ All checks passed/i,
+    /https:\/\/github\.com\/[^\s]+\/pull\/\d+/,
+    /Successfully created PR/i,
+    /Commit [a-f0-9]{7,40}/i
+  ];
+  INTERMEDIATE_OUTPUT_PATTERNS = [
+    /^Running tests?\.\.\./im,
+    /^Building\.\.\./im,
+    /^Installing dependencies/im
+  ];
+});
+
 // src/services/swarm-decision-loop.ts
 var exports_swarm_decision_loop = {};
 __export(exports_swarm_decision_loop, {
@@ -157,10 +294,11 @@ __export(exports_swarm_decision_loop, {
   handleConfirmDecision: () => handleConfirmDecision,
   handleBlocked: () => handleBlocked,
   handleAutonomousDecision: () => handleAutonomousDecision,
-  executeDecision: () => executeDecision
+  executeDecision: () => executeDecision,
+  checkAllTasksComplete: () => checkAllTasksComplete
 });
 import * as path from "node:path";
-import {ModelType as ModelType2} from "@elizaos/core";
+import {ModelType as ModelType3} from "@elizaos/core";
 function toContextSummary(taskCtx) {
   return {
     sessionId: taskCtx.sessionId,
@@ -203,6 +341,40 @@ function isOutOfScopeAccess(promptText, workdir) {
     return !resolved.startsWith(resolvedWorkdir + path.sep) && resolved !== resolvedWorkdir;
   });
 }
+function checkAllTasksComplete(ctx) {
+  const tasks = Array.from(ctx.tasks.values());
+  if (tasks.length === 0)
+    return;
+  const terminalStates = new Set(["completed", "stopped", "error"]);
+  const allDone = tasks.every((t) => terminalStates.has(t.status));
+  if (!allDone)
+    return;
+  const completed = tasks.filter((t) => t.status === "completed");
+  const stopped = tasks.filter((t) => t.status === "stopped");
+  const errored = tasks.filter((t) => t.status === "error");
+  const parts = [];
+  if (completed.length > 0) {
+    parts.push(`${completed.length} completed`);
+  }
+  if (stopped.length > 0) {
+    parts.push(`${stopped.length} stopped`);
+  }
+  if (errored.length > 0) {
+    parts.push(`${errored.length} errored`);
+  }
+  ctx.sendChatMessage(`All ${tasks.length} coding agents finished (${parts.join(", ")}). Review their work when you're ready.`, "coding-agent");
+  ctx.broadcast({
+    type: "swarm_complete",
+    sessionId: "",
+    timestamp: Date.now(),
+    data: {
+      total: tasks.length,
+      completed: completed.length,
+      stopped: stopped.length,
+      errored: errored.length
+    }
+  });
+}
 async function fetchRecentOutput(ctx, sessionId, lines = 50) {
   if (!ctx.ptyService)
     return "";
@@ -215,7 +387,7 @@ async function fetchRecentOutput(ctx, sessionId, lines = 50) {
 async function makeCoordinationDecision(ctx, taskCtx, promptText, recentOutput) {
   const prompt = buildCoordinationPrompt(toContextSummary(taskCtx), promptText, recentOutput, toDecisionHistory(taskCtx));
   try {
-    const result = await ctx.runtime.useModel(ModelType2.TEXT_SMALL, {
+    const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
       prompt
     });
     return parseCoordinationResponse(result);
@@ -256,6 +428,7 @@ async function executeDecision(ctx, sessionId, decision) {
       ctx.ptyService.stopSession(sessionId).catch((err) => {
         ctx.log(`Failed to stop session after LLM-detected completion: ${err}`);
       });
+      checkAllTasksComplete(ctx);
       break;
     }
     case "escalate":
@@ -357,10 +530,10 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
   }
   switch (ctx.getSupervisionLevel()) {
     case "autonomous":
-      await handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, "");
+      await handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, "", eventData.promptInfo?.type);
       break;
     case "confirm":
-      await handleConfirmDecision(ctx, sessionId, taskCtx, promptText, "");
+      await handleConfirmDecision(ctx, sessionId, taskCtx, promptText, "", eventData.promptInfo?.type);
       break;
     case "notify":
       taskCtx.decisions.push({
@@ -387,21 +560,54 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
       const raw = await fetchRecentOutput(ctx, sessionId);
       turnOutput = cleanForChat(raw);
     }
-    const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
+    const agentDecisionCb = ctx.getAgentDecisionCallback();
     let decision = null;
-    try {
-      const result = await ctx.runtime.useModel(ModelType2.TEXT_SMALL, {
-        prompt
-      });
-      decision = parseCoordinationResponse(result);
-    } catch (err) {
-      ctx.log(`Turn-complete LLM call failed: ${err}`);
+    let decisionFromPipeline = false;
+    const triageCtx = {
+      eventType: "turn_complete",
+      promptText: "",
+      recentOutput: turnOutput,
+      originalTask: taskCtx.originalTask
+    };
+    const tier = agentDecisionCb ? await classifyEventTier(ctx.runtime, triageCtx, ctx.log) : "routine";
+    if (tier === "routine") {
+      const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
+      try {
+        const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
+          prompt
+        });
+        decision = parseCoordinationResponse(result);
+      } catch (err) {
+        ctx.log(`Turn-complete LLM call failed: ${err}`);
+      }
+    } else {
+      if (agentDecisionCb) {
+        const eventMessage = buildTurnCompleteEventMessage(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
+        try {
+          decision = await agentDecisionCb(eventMessage, sessionId, taskCtx);
+          if (decision)
+            decisionFromPipeline = true;
+        } catch (err) {
+          ctx.log(`Agent decision callback failed for turn-complete: ${err} \u2014 falling back to small LLM`);
+        }
+      }
+      if (!decision) {
+        const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
+        try {
+          const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
+            prompt
+          });
+          decision = parseCoordinationResponse(result);
+        } catch (err) {
+          ctx.log(`Turn-complete LLM fallback call failed: ${err}`);
+        }
+      }
     }
     if (!decision) {
-      ctx.log(`Turn-complete for "${taskCtx.label}": LLM invalid response \u2014 defaulting to complete`);
+      ctx.log(`Turn-complete for "${taskCtx.label}": all decision paths failed \u2014 escalating`);
       decision = {
-        action: "complete",
-        reasoning: "LLM returned invalid response \u2014 defaulting to complete"
+        action: "escalate",
+        reasoning: "All decision paths returned invalid response \u2014 escalating for human review"
       };
     }
     ctx.log(`Turn assessment for "${taskCtx.label}": ${decision.action}${decision.action === "respond" ? ` \u2192 "${(decision.response ?? "").slice(0, 80)}"` : ""} \u2014 ${decision.reasoning.slice(0, 120)}`);
@@ -422,19 +628,21 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
         reasoning: decision.reasoning
       }
     });
-    if (decision.action === "respond") {
-      const instruction = decision.response ?? "";
-      const preview = instruction.length > 120 ? `${instruction.slice(0, 120)}...` : instruction;
-      ctx.sendChatMessage(`[${taskCtx.label}] Turn done, continuing: ${preview}`, "coding-agent");
-    } else if (decision.action === "escalate") {
-      ctx.sendChatMessage(`[${taskCtx.label}] Turn finished \u2014 needs your attention: ${decision.reasoning}`, "coding-agent");
+    if (!decisionFromPipeline) {
+      if (decision.action === "respond") {
+        const instruction = decision.response ?? "";
+        const preview = instruction.length > 120 ? `${instruction.slice(0, 120)}...` : instruction;
+        ctx.sendChatMessage(`[${taskCtx.label}] Turn done, continuing: ${preview}`, "coding-agent");
+      } else if (decision.action === "escalate") {
+        ctx.sendChatMessage(`[${taskCtx.label}] Turn finished \u2014 needs your attention: ${decision.reasoning}`, "coding-agent");
+      }
     }
     await executeDecision(ctx, sessionId, decision);
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
   }
 }
-async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, recentOutput) {
+async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, recentOutput, promptType) {
   if (ctx.inFlightDecisions.has(sessionId)) {
     ctx.log(`Skipping duplicate decision for ${sessionId} (in-flight)`);
     return;
@@ -445,14 +653,41 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
     if (!output) {
       output = await fetchRecentOutput(ctx, sessionId);
     }
-    let decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
+    const agentDecisionCb = ctx.getAgentDecisionCallback();
+    let decision = null;
+    let decisionFromPipeline = false;
+    const triageCtx = {
+      eventType: "blocked",
+      promptText,
+      promptType,
+      recentOutput: output,
+      originalTask: taskCtx.originalTask
+    };
+    const tier = agentDecisionCb ? await classifyEventTier(ctx.runtime, triageCtx, ctx.log) : "routine";
+    if (tier === "routine") {
+      decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
+    } else {
+      if (agentDecisionCb) {
+        const eventMessage = buildBlockedEventMessage(toContextSummary(taskCtx), promptText, output, toDecisionHistory(taskCtx));
+        try {
+          decision = await agentDecisionCb(eventMessage, sessionId, taskCtx);
+          if (decision)
+            decisionFromPipeline = true;
+        } catch (err) {
+          ctx.log(`Agent decision callback failed: ${err} \u2014 falling back to small LLM`);
+        }
+      }
+      if (!decision) {
+        decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
+      }
+    }
     if (!decision) {
       taskCtx.decisions.push({
         timestamp: Date.now(),
         event: "blocked",
         promptText,
         decision: "escalate",
-        reasoning: "LLM returned invalid coordination response"
+        reasoning: "All decision paths returned invalid coordination response"
       });
       ctx.broadcast({
         type: "escalation",
@@ -494,19 +729,21 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
         reasoning: decision.reasoning
       }
     });
-    if (decision.action === "respond") {
-      const actionDesc = decision.useKeys ? `Sent keys: ${decision.keys?.join(", ")}` : decision.response ? `Responded: ${decision.response.length > 100 ? `${decision.response.slice(0, 100)}...` : decision.response}` : "Responded";
-      const reasonExcerpt = decision.reasoning.length > 150 ? `${decision.reasoning.slice(0, 150)}...` : decision.reasoning;
-      ctx.sendChatMessage(`[${taskCtx.label}] ${actionDesc} \u2014 ${reasonExcerpt}`, "coding-agent");
-    } else if (decision.action === "escalate") {
-      ctx.sendChatMessage(`[${taskCtx.label}] Needs your attention: ${decision.reasoning}`, "coding-agent");
+    if (!decisionFromPipeline) {
+      if (decision.action === "respond") {
+        const actionDesc = decision.useKeys ? `Sent keys: ${decision.keys?.join(", ")}` : decision.response ? `Responded: ${decision.response.length > 100 ? `${decision.response.slice(0, 100)}...` : decision.response}` : "Responded";
+        const reasonExcerpt = decision.reasoning.length > 150 ? `${decision.reasoning.slice(0, 150)}...` : decision.reasoning;
+        ctx.sendChatMessage(`[${taskCtx.label}] ${actionDesc} \u2014 ${reasonExcerpt}`, "coding-agent");
+      } else if (decision.action === "escalate") {
+        ctx.sendChatMessage(`[${taskCtx.label}] Needs your attention: ${decision.reasoning}`, "coding-agent");
+      }
     }
     await executeDecision(ctx, sessionId, decision);
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
   }
 }
-async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recentOutput) {
+async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recentOutput, promptType) {
   if (ctx.inFlightDecisions.has(sessionId))
     return;
   ctx.inFlightDecisions.add(sessionId);
@@ -515,7 +752,34 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
     if (!output) {
       output = await fetchRecentOutput(ctx, sessionId);
     }
-    const decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
+    const agentDecisionCb = ctx.getAgentDecisionCallback();
+    let decision = null;
+    let decisionFromPipeline = false;
+    const triageCtx = {
+      eventType: "blocked",
+      promptText,
+      promptType,
+      recentOutput: output,
+      originalTask: taskCtx.originalTask
+    };
+    const tier = agentDecisionCb ? await classifyEventTier(ctx.runtime, triageCtx, ctx.log) : "routine";
+    if (tier === "routine") {
+      decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
+    } else {
+      if (agentDecisionCb) {
+        const eventMessage = buildBlockedEventMessage(toContextSummary(taskCtx), promptText, output, toDecisionHistory(taskCtx));
+        try {
+          decision = await agentDecisionCb(eventMessage, sessionId, taskCtx);
+          if (decision)
+            decisionFromPipeline = true;
+        } catch (err) {
+          ctx.log(`Agent decision callback failed (confirm): ${err} \u2014 falling back to small LLM`);
+        }
+      }
+      if (!decision) {
+        decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
+      }
+    }
     if (!decision) {
       ctx.pendingDecisions.set(sessionId, {
         sessionId,
@@ -523,7 +787,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
         recentOutput: output,
         llmDecision: {
           action: "escalate",
-          reasoning: "LLM returned invalid response \u2014 needs human review"
+          reasoning: "All decision paths returned invalid response \u2014 needs human review"
         },
         taskContext: taskCtx,
         createdAt: Date.now()
@@ -546,7 +810,8 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
         prompt: promptText,
         suggestedAction: decision?.action,
         suggestedResponse: decision?.response,
-        reasoning: decision?.reasoning
+        reasoning: decision?.reasoning,
+        fromPipeline: decisionFromPipeline
       }
     });
   } finally {
@@ -556,6 +821,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
 var MAX_AUTO_RESPONSES = 10;
 var init_swarm_decision_loop = __esm(() => {
   init_ansi_utils();
+  init_swarm_event_triage();
 });
 
 // src/actions/finalize-workspace.ts
@@ -1730,6 +1996,11 @@ async function initializePTYManager(ctx) {
     bunManager.on("session_ready", (session) => {
       ctx.log(`session_ready event received for ${session.id} (type: ${session.type}, status: ${session.status})`);
       ctx.emitEvent(session.id, "ready", { session });
+      if (ctx.hasActiveTask?.(session.id) && ctx.taskResponseMarkers.has(session.id)) {
+        const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
+        ctx.log(`session_ready for active task ${session.id} \u2014 forwarding as task_complete (stall classifier path)`);
+        ctx.emitEvent(session.id, "task_complete", { session, response });
+      }
     });
     bunManager.on("session_exit", (id, code) => {
       ctx.emitEvent(id, "stopped", { reason: `exit code ${code}` });
@@ -1808,6 +2079,11 @@ async function initializePTYManager(ctx) {
   }
   nodeManager.on("session_ready", (session) => {
     ctx.emitEvent(session.id, "ready", { session });
+    if (ctx.hasActiveTask?.(session.id) && ctx.taskResponseMarkers.has(session.id)) {
+      const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
+      ctx.log(`session_ready for active task ${session.id} \u2014 forwarding as task_complete (stall classifier path)`);
+      ctx.emitEvent(session.id, "task_complete", { session, response });
+    }
   });
   nodeManager.on("blocking_prompt", (session, promptInfo, autoResponded) => {
     ctx.emitEvent(session.id, "blocked", { promptInfo, autoResponded });
@@ -2228,12 +2504,35 @@ import {logger} from "@elizaos/core";
 // src/services/swarm-idle-watchdog.ts
 init_ansi_utils();
 init_swarm_decision_loop();
-import {ModelType as ModelType3} from "@elizaos/core";
+import {ModelType as ModelType4} from "@elizaos/core";
 async function scanIdleSessions(ctx) {
   const now = Date.now();
   for (const taskCtx of ctx.tasks.values()) {
     if (taskCtx.status !== "active")
       continue;
+    if (ctx.ptyService) {
+      const session = ctx.ptyService.getSession(taskCtx.sessionId);
+      if (!session) {
+        ctx.log(`Idle watchdog: "${taskCtx.label}" \u2014 PTY session no longer exists, marking as stopped`);
+        taskCtx.status = "stopped";
+        taskCtx.decisions.push({
+          timestamp: now,
+          event: "idle_watchdog",
+          promptText: "PTY session no longer exists",
+          decision: "stopped",
+          reasoning: "Underlying PTY process is gone (likely killed during restart)"
+        });
+        ctx.broadcast({
+          type: "stopped",
+          sessionId: taskCtx.sessionId,
+          timestamp: now,
+          data: { reason: "pty_session_gone" }
+        });
+        ctx.sendChatMessage(`[${taskCtx.label}] Session lost \u2014 the agent process is no longer running (likely killed during a restart).`, "coding-agent");
+        checkAllTasksComplete(ctx);
+        continue;
+      }
+    }
     const idleMs = now - taskCtx.lastActivityAt;
     if (idleMs < IDLE_THRESHOLD_MS)
       continue;
@@ -2241,7 +2540,8 @@ async function scanIdleSessions(ctx) {
       continue;
     if (ctx.ptyService) {
       try {
-        const currentOutput = await ctx.ptyService.getSessionOutput(taskCtx.sessionId, 20);
+        const rawOutput = await ctx.ptyService.getSessionOutput(taskCtx.sessionId, 20);
+        const currentOutput = stripAnsi(rawOutput).trim();
         const lastSeen = ctx.lastSeenOutput.get(taskCtx.sessionId) ?? "";
         ctx.lastSeenOutput.set(taskCtx.sessionId, currentOutput);
         if (currentOutput !== lastSeen) {
@@ -2256,17 +2556,18 @@ async function scanIdleSessions(ctx) {
     taskCtx.idleCheckCount++;
     const idleMinutes = Math.round(idleMs / 60000);
     ctx.log(`Idle watchdog: "${taskCtx.label}" idle for ${idleMinutes}m (check ${taskCtx.idleCheckCount}/${MAX_IDLE_CHECKS})`);
-    if (taskCtx.idleCheckCount > MAX_IDLE_CHECKS) {
-      ctx.log(`Idle watchdog: force-escalating "${taskCtx.label}" after ${MAX_IDLE_CHECKS} checks`);
+    if (taskCtx.idleCheckCount >= MAX_IDLE_CHECKS) {
+      ctx.log(`Idle watchdog: force-stopping "${taskCtx.label}" after ${MAX_IDLE_CHECKS} checks`);
+      taskCtx.status = "stopped";
       taskCtx.decisions.push({
         timestamp: now,
         event: "idle_watchdog",
         promptText: `Session idle for ${idleMinutes} minutes`,
-        decision: "escalate",
-        reasoning: `Force-escalated after ${MAX_IDLE_CHECKS} idle checks with no activity`
+        decision: "stopped",
+        reasoning: `Force-stopped after ${MAX_IDLE_CHECKS} idle checks with no activity`
       });
       ctx.broadcast({
-        type: "escalation",
+        type: "stopped",
         sessionId: taskCtx.sessionId,
         timestamp: now,
         data: {
@@ -2275,7 +2576,22 @@ async function scanIdleSessions(ctx) {
           idleCheckCount: taskCtx.idleCheckCount
         }
       });
-      ctx.sendChatMessage(`[${taskCtx.label}] Session has been idle for ${idleMinutes} minutes with no progress. Needs your attention.`, "coding-agent");
+      ctx.sendChatMessage(`[${taskCtx.label}] Session stopped \u2014 idle for ${idleMinutes} minutes with no progress.`, "coding-agent");
+      if (ctx.ptyService) {
+        try {
+          await ctx.ptyService.stopSession(taskCtx.sessionId);
+        } catch (err) {
+          ctx.log(`Idle watchdog: failed to stop session ${taskCtx.sessionId}: ${err}`);
+          taskCtx.status = "error";
+          ctx.broadcast({
+            type: "error",
+            sessionId: taskCtx.sessionId,
+            timestamp: now,
+            data: { message: `Failed to stop idle session: ${err}` }
+          });
+        }
+      }
+      checkAllTasksComplete(ctx);
       continue;
     }
     await handleIdleCheck(ctx, taskCtx, idleMinutes);
@@ -2311,7 +2627,7 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
     const prompt = buildIdleCheckPrompt(contextSummary, recentOutput, idleMinutes, taskCtx.idleCheckCount, MAX_IDLE_CHECKS, decisionHistory);
     let decision = null;
     try {
-      const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
+      const result = await ctx.runtime.useModel(ModelType4.TEXT_SMALL, {
         prompt
       });
       decision = parseCoordinationResponse(result);
@@ -2362,6 +2678,7 @@ var MAX_IDLE_CHECKS = 4;
 // src/services/swarm-coordinator.ts
 var UNREGISTERED_BUFFER_MS = 2000;
 var IDLE_SCAN_INTERVAL_MS = 60 * 1000;
+var PAUSE_TIMEOUT_MS = 30000;
 
 class SwarmCoordinator {
   static serviceType = "SWARM_COORDINATOR";
@@ -2375,10 +2692,14 @@ class SwarmCoordinator {
   inFlightDecisions = new Set;
   chatCallback = null;
   wsBroadcast = null;
+  agentDecisionCb = null;
   unregisteredBuffer = new Map;
   idleWatchdogTimer = null;
   lastSeenOutput = new Map;
   lastToolNotification = new Map;
+  _paused = false;
+  pauseBuffer = [];
+  pauseTimeout = null;
   constructor(runtime) {
     this.runtime = runtime;
   }
@@ -2390,6 +2711,13 @@ class SwarmCoordinator {
     this.wsBroadcast = cb;
     this.log("WS broadcast callback wired");
   }
+  setAgentDecisionCallback(cb) {
+    this.agentDecisionCb = cb;
+    this.log("Agent decision callback wired \u2014 events will route through Milaidy");
+  }
+  getAgentDecisionCallback() {
+    return this.agentDecisionCb;
+  }
   sendChatMessage(text, source) {
     if (!this.chatCallback)
       return;
@@ -2432,8 +2760,49 @@ class SwarmCoordinator {
     this.unregisteredBuffer.clear();
     this.lastSeenOutput.clear();
     this.lastToolNotification.clear();
+    this.agentDecisionCb = null;
+    this._paused = false;
+    if (this.pauseTimeout) {
+      clearTimeout(this.pauseTimeout);
+      this.pauseTimeout = null;
+    }
+    this.pauseBuffer = [];
     this.log("SwarmCoordinator stopped");
   }
+  get isPaused() {
+    return this._paused;
+  }
+  pause() {
+    if (this._paused)
+      return;
+    this._paused = true;
+    this.log("Coordinator paused \u2014 buffering LLM decisions until user message is processed");
+    this.broadcast({ type: "coordinator_paused", sessionId: "", timestamp: Date.now(), data: {} });
+    this.pauseTimeout = setTimeout(() => {
+      if (this._paused) {
+        this.log("Coordinator auto-resuming after timeout");
+        this.resume();
+      }
+    }, PAUSE_TIMEOUT_MS);
+  }
+  resume() {
+    if (!this._paused)
+      return;
+    this._paused = false;
+    if (this.pauseTimeout) {
+      clearTimeout(this.pauseTimeout);
+      this.pauseTimeout = null;
+    }
+    this.log(`Coordinator resumed \u2014 replaying ${this.pauseBuffer.length} buffered events`);
+    this.broadcast({ type: "coordinator_resumed", sessionId: "", timestamp: Date.now(), data: {} });
+    const buffered = [...this.pauseBuffer];
+    this.pauseBuffer = [];
+    for (const entry of buffered) {
+      this.handleSessionEvent(entry.sessionId, entry.event, entry.data).catch((err) => {
+        this.log(`Error replaying buffered event: ${err}`);
+      });
+    }
+  }
   registerTask(sessionId, context) {
     this.tasks.set(sessionId, {
       sessionId,
@@ -2560,6 +2929,20 @@ class SwarmCoordinator {
     }
     taskCtx.lastActivityAt = Date.now();
     taskCtx.idleCheckCount = 0;
+    if (this._paused && (event === "blocked" || event === "task_complete")) {
+      const eventData = data;
+      if (!(event === "blocked" && eventData.autoResponded)) {
+        this.broadcast({
+          type: event === "blocked" ? "blocked_buffered" : "turn_complete_buffered",
+          sessionId,
+          timestamp: Date.now(),
+          data
+        });
+        this.pauseBuffer.push({ sessionId, event, data });
+        this.log(`Buffered "${event}" for ${taskCtx.label} (coordinator paused)`);
+        return;
+      }
+    }
     switch (event) {
       case "blocked":
         await handleBlocked(this, sessionId, taskCtx, data);
@@ -2584,6 +2967,7 @@ class SwarmCoordinator {
         });
         const errorMsg = data.message ?? "unknown error";
         this.sendChatMessage(`"${taskCtx.label}" hit an error: ${errorMsg}`, "coding-agent");
+        checkAllTasksComplete(this);
         break;
       }
       case "stopped":
@@ -2595,6 +2979,7 @@ class SwarmCoordinator {
           timestamp: Date.now(),
           data
         });
+        checkAllTasksComplete(this);
         break;
       case "ready":
         this.broadcast({
@@ -2615,6 +3000,10 @@ class SwarmCoordinator {
         });
         const toolData = data;
         const now = Date.now();
+        const STARTUP_GRACE_MS = 1e4;
+        if (now - taskCtx.registeredAt < STARTUP_GRACE_MS) {
+          break;
+        }
         const lastNotif = this.lastToolNotification.get(sessionId) ?? 0;
         if (now - lastNotif > 30000) {
           this.lastToolNotification.set(sessionId, now);
@@ -2650,6 +3039,9 @@ class SwarmCoordinator {
   async executeDecision(sessionId, decision) {
     return executeDecision(this, sessionId, decision);
   }
+  async executeEventDecision(sessionId, decision) {
+    return executeDecision(this, sessionId, decision);
+  }
   setSupervisionLevel(level) {
     this.supervisionLevel = level;
     this.broadcast({
@@ -2794,7 +3186,14 @@ class PTYService {
       metricsTracker: this.metricsTracker,
       traceEntries: this.traceEntries,
       maxTraceEntries: PTYService.MAX_TRACE_ENTRIES,
-      log: (msg) => this.log(msg)
+      log: (msg) => this.log(msg),
+      hasActiveTask: (sessionId) => {
+        const coordinator = this.coordinator;
+        if (!coordinator)
+          return false;
+        const taskCtx = coordinator.getTaskContext(sessionId);
+        return taskCtx?.status === "active";
+      }
     });
     this.manager = result.manager;
     this.usingBunWorker = result.usingBunWorker;
@@ -5248,7 +5647,8 @@ async function handleCoordinatorRoutes(req, res, pathname, ctx) {
     return true;
   }
   if (method === "GET" && subPath === "/status") {
-    const tasks = coordinator.getAllTaskContexts();
+    const allTasks = coordinator.getAllTaskContexts();
+    const tasks = allTasks.filter((t) => t.status !== "stopped" && t.status !== "completed" && t.status !== "error");
     sendJson(res, {
       supervisionLevel: coordinator.getSupervisionLevel(),
       taskCount: tasks.length,
@@ -5652,10 +6052,12 @@ export {
   src_default as default,
   createCodingAgentRouteHandler,
   codingAgentPlugin,
+  buildTurnCompleteEventMessage,
+  buildBlockedEventMessage,
   SwarmCoordinator,
   PTYService,
   CodingWorkspaceService
 };
 
-//# debugId=7D1565B17FF6D63964756E2164756E21
+//# debugId=0100F6538A0A9D6264756E2164756E21
 //# sourceMappingURL=index.js.map