@elizaos/plugin-agent-orchestrator 0.3.11 → 0.3.12

package/dist/index.js

@@ -537,7 +537,8 @@ __export(exports_swarm_decision_loop, {
   handleBlocked: () => handleBlocked,
   handleAutonomousDecision: () => handleAutonomousDecision,
   executeDecision: () => executeDecision,
-  checkAllTasksComplete: () => checkAllTasksComplete
+  checkAllTasksComplete: () => checkAllTasksComplete,
+  POST_SEND_COOLDOWN_MS: () => POST_SEND_COOLDOWN_MS
 });
 import * as path from "node:path";
 import { ModelType as ModelType3 } from "@elizaos/core";
@@ -786,7 +787,8 @@ async function executeDecision(ctx, sessionId, decision) {
   if (!ctx.ptyService)
     return;
   switch (decision.action) {
-    case "respond":
+    case "respond": {
+      const taskCtx = ctx.tasks.get(sessionId);
       if (decision.useKeys && decision.keys) {
         await ctx.ptyService.sendKeysToSession(sessionId, decision.keys);
       } else if (decision.response !== undefined) {
@@ -796,7 +798,10 @@ async function executeDecision(ctx, sessionId, decision) {
           commitSharedDecisionIndex(ctx, sessionId, snapshotIndex);
         }
       }
+      if (taskCtx)
+        taskCtx.lastInputSentAt = Date.now();
       break;
+    }
     case "complete": {
       const taskCtx = ctx.tasks.get(sessionId);
       if (taskCtx) {
@@ -958,6 +963,13 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
     ctx.pendingTurnComplete.set(sessionId, data);
     return;
   }
+  if (taskCtx.lastInputSentAt) {
+    const elapsed = Date.now() - taskCtx.lastInputSentAt;
+    if (elapsed < POST_SEND_COOLDOWN_MS) {
+      ctx.log(`Suppressing turn-complete for "${taskCtx.label}" — ` + `${Math.round(elapsed / 1000)}s since last input (cooldown ${POST_SEND_COOLDOWN_MS / 1000}s)`);
+      return;
+    }
+  }
   ctx.inFlightDecisions.add(sessionId);
   try {
     ctx.log(`Turn complete for "${taskCtx.label}" — assessing whether task is done`);
@@ -1207,7 +1219,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
     await drainPendingBlocked(ctx, sessionId);
   }
 }
-var DECISION_CB_TIMEOUT_MS = 30000, MAX_AUTO_RESPONSES = 10;
+var DECISION_CB_TIMEOUT_MS = 30000, MAX_AUTO_RESPONSES = 10, POST_SEND_COOLDOWN_MS = 15000;
 var init_swarm_decision_loop = __esm(() => {
   init_ansi_utils();
   init_swarm_event_triage();
@@ -2230,13 +2242,13 @@ var sendToAgentAction = {
 import * as os from "node:os";
 import * as path2 from "node:path";
 import {
-  logger as logger3
+  logger as logger4
 } from "@elizaos/core";
 
 // src/services/pty-service.ts
 import { appendFile, mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname, join as join2 } from "node:path";
-import { logger as logger2 } from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
 import {
   checkAdapters,
   createAdapter,
@@ -3141,6 +3153,9 @@ async function classifyAndDecideForCoordinator(ctx) {
   }
 }
 
+// src/services/pty-service.ts
+init_swarm_decision_loop();
+
 // src/services/swarm-coordinator.ts
 init_ansi_utils();
 init_swarm_decision_loop();
@@ -3822,6 +3837,65 @@ class SwarmCoordinator {
   }
 }
 
+// src/services/debug-capture.ts
+import { logger as logger2 } from "@elizaos/core";
+var captureManager = null;
+var initAttempted = false;
+function isDebugCaptureEnabled() {
+  return process.env.PARALLAX_DEBUG_CAPTURE === "1";
+}
+async function ensureCaptureManager() {
+  if (captureManager)
+    return captureManager;
+  if (initAttempted)
+    return null;
+  initAttempted = true;
+  if (!isDebugCaptureEnabled())
+    return null;
+  try {
+    const mod = await import("pty-state-capture");
+    const { PTYStateCaptureManager } = mod;
+    captureManager = new PTYStateCaptureManager({
+      outputRootDir: ".parallax/pty-captures",
+      defaultRows: 80,
+      defaultCols: 220
+    });
+    logger2.info("[debug-capture] PTY state capture enabled — writing to .parallax/pty-captures/");
+    return captureManager;
+  } catch {
+    logger2.debug("[debug-capture] pty-state-capture not available — capture disabled");
+    return null;
+  }
+}
+async function captureSessionOpen(sessionId, agentType) {
+  const mgr = await ensureCaptureManager();
+  if (!mgr)
+    return;
+  try {
+    await mgr.openSession(sessionId, { source: agentType });
+  } catch (err) {
+    logger2.debug(`[debug-capture] Failed to open session ${sessionId}: ${err}`);
+  }
+}
+async function captureFeed(sessionId, chunk, direction = "stdout") {
+  if (!captureManager)
+    return;
+  try {
+    await captureManager.feed(sessionId, chunk, direction);
+  } catch (err) {
+    logger2.debug(`[debug-capture] Feed error for ${sessionId}: ${err}`);
+  }
+}
+async function captureLifecycle(sessionId, event, detail) {
+  if (!captureManager)
+    return;
+  try {
+    await captureManager.lifecycle(sessionId, event, detail);
+  } catch (err) {
+    logger2.debug(`[debug-capture] Lifecycle error for ${sessionId}: ${err}`);
+  }
+}
+
 // src/services/pty-service.ts
 function getCoordinator(runtime) {
   const ptyService = runtime.getService("PTY_SERVICE");
@@ -3865,16 +3939,16 @@ class PTYService {
     const existing = servicesMap?.get?.("SWARM_COORDINATOR");
     if (existing && existing.length > 0) {
       service.coordinator = existing[0];
-      logger2.info("[PTYService] SwarmCoordinator already registered, skipping duplicate start");
+      logger3.info("[PTYService] SwarmCoordinator already registered, skipping duplicate start");
     } else {
       try {
         const coordinator = new SwarmCoordinator(runtime);
         coordinator.start(service);
         service.coordinator = coordinator;
         servicesMap?.set?.("SWARM_COORDINATOR", [coordinator]);
-        logger2.info("[PTYService] SwarmCoordinator wired and started");
+        logger3.info("[PTYService] SwarmCoordinator wired and started");
       } catch (err) {
-        logger2.error(`[PTYService] Failed to wire SwarmCoordinator: ${err}`);
+        logger3.error(`[PTYService] Failed to wire SwarmCoordinator: ${err}`);
       }
     }
     return service;
@@ -4098,6 +4172,21 @@ class PTYService {
     if (this.usingBunWorker) {
       setupOutputBuffer(ctx, session.id);
     }
+    if (isDebugCaptureEnabled()) {
+      captureSessionOpen(session.id, resolvedAgentType).catch(() => {});
+      if (this.usingBunWorker) {
+        this.manager.onSessionData(session.id, (data) => {
+          captureFeed(session.id, data, "stdout");
+        });
+      } else {
+        const ptySession = this.manager.getSession(session.id);
+        if (ptySession) {
+          ptySession.on("output", (data) => {
+            captureFeed(session.id, data, "stdout");
+          });
+        }
+      }
+    }
     if (resolvedInitialTask) {
       setupDeferredTaskDelivery(ctx, session, resolvedInitialTask, resolvedAgentType);
     }
@@ -4125,6 +4214,7 @@ class PTYService {
   async sendToSession(sessionId, input) {
     if (!this.manager)
       throw new Error("PTYService not initialized");
+    captureFeed(sessionId, input, "stdin");
     return sendToSession(this.ioContext(), sessionId, input);
   }
   async sendKeysToSession(sessionId, keys) {
@@ -4135,6 +4225,7 @@ class PTYService {
   async stopSession(sessionId, force = false) {
     if (!this.manager)
       throw new Error("PTYService not initialized");
+    captureLifecycle(sessionId, "session_stopped", force ? "force" : undefined);
     return stopSession(this.ioContext(), sessionId, this.sessionMetadata, this.sessionWorkdirs, (msg) => this.log(msg), force);
   }
   get defaultApprovalPreset() {
@@ -4210,12 +4301,12 @@ class PTYService {
   handleHookEvent(sessionId, event, data) {
     const summary = event === "tool_running" ? `tool=${data.toolName ?? "?"}` : event === "permission_approved" ? `tool=${data.tool ?? "?"}` : JSON.stringify(data);
     if (event === "tool_running" || event === "permission_approved") {
-      logger2.debug(`[PTYService] Hook event for ${sessionId}: ${event} ${summary}`);
+      logger3.debug(`[PTYService] Hook event for ${sessionId}: ${event} ${summary}`);
     } else {
       this.log(`Hook event for ${sessionId}: ${event} ${summary}`);
     }
     if (this.manager && this.usingBunWorker) {
-      this.manager.notifyHookEvent(sessionId, event).catch((err) => logger2.debug(`[PTYService] Failed to forward hook event to session: ${err}`));
+      this.manager.notifyHookEvent(sessionId, event).catch((err) => logger3.debug(`[PTYService] Failed to forward hook event to session: ${err}`));
     }
     switch (event) {
       case "tool_running":
@@ -4249,6 +4340,13 @@ class PTYService {
     if (meta?.coordinatorManaged && this.coordinator?.getSupervisionLevel() === "autonomous") {
       const taskCtx = this.coordinator.getTaskContext(sessionId);
       if (taskCtx) {
+        if (taskCtx.lastInputSentAt) {
+          const elapsed = Date.now() - taskCtx.lastInputSentAt;
+          if (elapsed < POST_SEND_COOLDOWN_MS) {
+            this.log(`Suppressing stall classification for ${sessionId} — ` + `${Math.round(elapsed / 1000)}s since coordinator sent input`);
+            return null;
+          }
+        }
         return classifyAndDecideForCoordinator({
           sessionId,
           recentOutput,
@@ -4413,7 +4511,7 @@ class PTYService {
     return this.metricsTracker.getAll();
   }
   log(message) {
-    logger2.debug(`[PTYService] ${message}`);
+    logger3.debug(`[PTYService] ${message}`);
   }
 }
 
@@ -4459,7 +4557,7 @@ var spawnAgentAction = {
   validate: async (runtime, _message) => {
     const ptyService = runtime.getService("PTY_SERVICE");
     if (!ptyService) {
-      logger3.warn("[SPAWN_CODING_AGENT] PTYService not available");
+      logger4.warn("[SPAWN_CODING_AGENT] PTYService not available");
       return false;
     }
     return true;
@@ -4572,7 +4670,7 @@ var spawnAgentAction = {
       ptyService.onSessionEvent((sessionId, event, data) => {
         if (sessionId !== session.id)
           return;
-        logger3.debug(`[Session ${sessionId}] ${event}: ${JSON.stringify(data)}`);
+        logger4.debug(`[Session ${sessionId}] ${event}: ${JSON.stringify(data)}`);
         if (!coordinator) {
           if (event === "blocked" && callback) {
             callback({
@@ -4624,7 +4722,7 @@ var spawnAgentAction = {
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger3.error("[SPAWN_CODING_AGENT] Failed to spawn agent:", errorMessage);
+      logger4.error("[SPAWN_CODING_AGENT] Failed to spawn agent:", errorMessage);
       if (callback) {
         await callback({
           text: `Failed to spawn coding agent: ${errorMessage}`
@@ -4672,7 +4770,7 @@ var spawnAgentAction = {
 
 // src/actions/coding-task-handlers.ts
 import {
-  logger as logger5,
+  logger as logger6,
   ModelType as ModelType5
 } from "@elizaos/core";
 // src/services/trajectory-feedback.ts
@@ -4749,12 +4847,12 @@ async function queryPastExperience(runtime, options = {}) {
     taskDescription,
     repo
   } = options;
-  const logger4 = getTrajectoryLogger(runtime);
-  if (!logger4)
+  const logger5 = getTrajectoryLogger(runtime);
+  if (!logger5)
     return [];
   const startDate = new Date(Date.now() - lookbackHours * 60 * 60 * 1000).toISOString();
   try {
-    const result = await withTimeout2(logger4.listTrajectories({
+    const result = await withTimeout2(logger5.listTrajectories({
       source: "orchestrator",
       limit: maxTrajectories,
       startDate
@@ -4765,7 +4863,7 @@ async function queryPastExperience(runtime, options = {}) {
     const maxScans = Math.min(result.trajectories.length, maxTrajectories);
     for (let scanIdx = 0;scanIdx < maxScans; scanIdx++) {
       const summary = result.trajectories[scanIdx];
-      const detail = await withTimeout2(logger4.getTrajectoryDetail(summary.id), QUERY_TIMEOUT_MS).catch(() => null);
+      const detail = await withTimeout2(logger5.getTrajectoryDetail(summary.id), QUERY_TIMEOUT_MS).catch(() => null);
       if (!detail?.steps)
         continue;
       const metadata = detail.metadata;
@@ -4843,7 +4941,7 @@ import * as fs from "node:fs";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
 import {
-  logger as logger4
+  logger as logger5
 } from "@elizaos/core";
 function createScratchDir() {
   const baseDir = path3.join(os2.homedir(), ".milady", "workspaces");
@@ -4888,7 +4986,7 @@ ${preview}` : `Agent "${label}" completed the task.`
           });
         }
         ptyService.stopSession(sessionId, true).catch((err) => {
-          logger4.warn(`[START_CODING_TASK] Failed to stop session for "${label}" after task complete: ${err}`);
+          logger5.warn(`[START_CODING_TASK] Failed to stop session for "${label}" after task complete: ${err}`);
         });
       }
       if (event === "error" && callback) {
@@ -4901,7 +4999,7 @@ ${preview}` : `Agent "${label}" completed the task.`
       const wsService = runtime.getService("CODING_WORKSPACE_SERVICE");
       if (wsService) {
         wsService.removeScratchDir(scratchDir).catch((err) => {
-          logger4.warn(`[START_CODING_TASK] Failed to cleanup scratch dir for "${label}": ${err}`);
+          logger5.warn(`[START_CODING_TASK] Failed to cleanup scratch dir for "${label}": ${err}`);
         });
       }
     }
@@ -4988,7 +5086,7 @@ ${taskList}
     }));
     return result?.trim() || "";
   } catch (err) {
-    logger5.warn(`Swarm context generation failed: ${err}`);
+    logger6.warn(`Swarm context generation failed: ${err}`);
     return "";
   }
 }
@@ -5160,7 +5258,7 @@ ${swarmContext}
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger5.error(`[START_CODING_TASK] Failed to spawn agent ${i + 1}:`, errorMessage);
+      logger6.error(`[START_CODING_TASK] Failed to spawn agent ${i + 1}:`, errorMessage);
       results.push({
         sessionId: "",
         agentType: specAgentType,
@@ -5192,7 +5290,7 @@ ${swarmContext}
   };
 }
 async function handleSingleAgent(ctx, task) {
-  logger5.debug(`[START_CODING_TASK] handleSingleAgent called, agentType=${ctx.defaultAgentType}, task=${task ? "yes" : "none"}, repo=${ctx.repo ?? "none"}`);
+  logger6.debug(`[START_CODING_TASK] handleSingleAgent called, agentType=${ctx.defaultAgentType}, task=${task ? "yes" : "none"}, repo=${ctx.repo ?? "none"}`);
   const {
     runtime,
     ptyService,
@@ -5252,14 +5350,14 @@ async function handleSingleAgent(ctx, task) {
   } else {
     workdir = createScratchDir();
   }
-  logger5.debug(`[START_CODING_TASK] Spawning ${agentType} agent, task: ${task ? `"${task.slice(0, 80)}..."` : "(none)"}, workdir: ${workdir}`);
+  logger6.debug(`[START_CODING_TASK] Spawning ${agentType} agent, task: ${task ? `"${task.slice(0, 80)}..."` : "(none)"}, workdir: ${workdir}`);
   try {
     if (agentType !== "shell" && agentType !== "pi") {
       const [preflight] = await ptyService.checkAvailableAgents([
         agentType
       ]);
       if (preflight && !preflight.installed) {
-        logger5.warn(`[START_CODING_TASK] ${preflight.adapter} CLI not installed`);
+        logger6.warn(`[START_CODING_TASK] ${preflight.adapter} CLI not installed`);
         if (callback) {
           await callback({
             text: `${preflight.adapter} CLI is not installed.
@@ -5269,7 +5367,7 @@ Docs: ${preflight.docsUrl}`
         }
         return { success: false, error: "AGENT_NOT_INSTALLED" };
       }
-      logger5.debug(`[START_CODING_TASK] Preflight OK: ${preflight?.adapter} installed`);
+      logger6.debug(`[START_CODING_TASK] Preflight OK: ${preflight?.adapter} installed`);
     }
     const piRequested = isPiAgentType(rawAgentType);
     const initialTask = piRequested ? toPiCommand(task) : task;
@@ -5285,7 +5383,7 @@ Docs: ${preflight.docsUrl}`
 
 `) || undefined;
     const coordinator = getCoordinator(runtime);
-    logger5.debug(`[START_CODING_TASK] Calling spawnSession (${agentType}, coordinator=${!!coordinator})`);
+    logger6.debug(`[START_CODING_TASK] Calling spawnSession (${agentType}, coordinator=${!!coordinator})`);
     const session = await ptyService.spawnSession({
       name: `coding-${Date.now()}`,
       agentType,
@@ -5304,7 +5402,7 @@ Docs: ${preflight.docsUrl}`
         label
       }
     });
-    logger5.debug(`[START_CODING_TASK] Session spawned: ${session.id} (${session.status})`);
+    logger6.debug(`[START_CODING_TASK] Session spawned: ${session.id} (${session.status})`);
     const isScratchWorkspace = !repo;
     const scratchDir = isScratchWorkspace ? workdir : null;
     registerSessionEvents(ptyService, runtime, session.id, label, scratchDir, callback, !!coordinator);
@@ -5345,7 +5443,7 @@ Session ID: ${session.id}` });
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    logger5.error("[START_CODING_TASK] Failed to spawn agent:", errorMessage);
+    logger6.error("[START_CODING_TASK] Failed to spawn agent:", errorMessage);
     if (callback) {
       await callback({
         text: `Failed to start coding agent: ${errorMessage}`
@@ -5526,7 +5624,7 @@ var startCodingTaskAction = {
 
 // src/actions/stop-agent.ts
 import {
-  logger as logger6
+  logger as logger7
 } from "@elizaos/core";
 var stopAgentAction = {
   name: "STOP_CODING_AGENT",
@@ -5605,7 +5703,7 @@ var stopAgentAction = {
         try {
           await ptyService.stopSession(session2.id);
         } catch (err) {
-          logger6.error(`Failed to stop session ${session2.id}: ${err}`);
+          logger7.error(`Failed to stop session ${session2.id}: ${err}`);
         }
       }
       if (state?.codingSession) {
@@ -7370,5 +7468,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=1AF5CF89CDA1169464756E2164756E21
+//# debugId=4383E51DF7A1F4A764756E2164756E21
 //# sourceMappingURL=index.js.map