@elizaos/plugin-agent-orchestrator 0.3.11 → 0.3.13

package/dist/index.js

@@ -537,7 +537,9 @@ __export(exports_swarm_decision_loop, {
   handleBlocked: () => handleBlocked,
   handleAutonomousDecision: () => handleAutonomousDecision,
   executeDecision: () => executeDecision,
-  checkAllTasksComplete: () => checkAllTasksComplete
+  clearDeferredTurnCompleteTimers: () => clearDeferredTurnCompleteTimers,
+  checkAllTasksComplete: () => checkAllTasksComplete,
+  POST_SEND_COOLDOWN_MS: () => POST_SEND_COOLDOWN_MS
 });
 import * as path from "node:path";
 import { ModelType as ModelType3 } from "@elizaos/core";
@@ -553,6 +555,12 @@ function withTimeout(promise, ms, label) {
     });
   });
 }
+function clearDeferredTurnCompleteTimers() {
+  for (const timer of deferredTurnCompleteTimers.values()) {
+    clearTimeout(timer);
+  }
+  deferredTurnCompleteTimers.clear();
+}
 function toContextSummary(taskCtx) {
   return {
     sessionId: taskCtx.sessionId,
@@ -732,14 +740,23 @@ function checkAllTasksComplete(ctx) {
   };
   if (swarmCompleteCb) {
     ctx.log("checkAllTasksComplete: swarm complete callback is wired — calling synthesis");
-    const taskSummaries = tasks.map((t) => ({
-      sessionId: t.sessionId,
-      label: t.label,
-      agentType: t.agentType,
-      originalTask: t.originalTask,
-      status: t.status,
-      completionSummary: t.completionSummary ?? ""
-    }));
+    const taskSummaries = tasks.map((t) => {
+      const decisions = ctx.sharedDecisions.filter((sd) => sd.agentLabel === t.label).map((sd) => sd.summary);
+      const summaryParts = [];
+      if (decisions.length > 0)
+        summaryParts.push(decisions.join("; "));
+      if (t.completionSummary)
+        summaryParts.push(t.completionSummary);
+      return {
+        sessionId: t.sessionId,
+        label: t.label,
+        agentType: t.agentType,
+        originalTask: t.originalTask,
+        status: t.status,
+        completionSummary: summaryParts.join(`
+`) || ""
+      };
+    });
     withTimeout(Promise.resolve().then(() => swarmCompleteCb({
       tasks: taskSummaries,
       total: tasks.length,
@@ -786,7 +803,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 +814,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) {
@@ -953,11 +974,45 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
   }
 }
 async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
+  if (taskCtx.status !== "active")
+    return;
   if (ctx.inFlightDecisions.has(sessionId)) {
     ctx.log(`Buffering turn-complete for ${sessionId} (in-flight decision running)`);
     ctx.pendingTurnComplete.set(sessionId, data);
     return;
   }
+  if (taskCtx.lastInputSentAt) {
+    const elapsed = Date.now() - taskCtx.lastInputSentAt;
+    if (elapsed < POST_SEND_COOLDOWN_MS) {
+      ctx.pendingTurnComplete.set(sessionId, data);
+      if (!deferredTurnCompleteTimers.has(sessionId)) {
+        const delayMs = POST_SEND_COOLDOWN_MS - elapsed + 50;
+        const timer = setTimeout(() => {
+          deferredTurnCompleteTimers.delete(sessionId);
+          const pendingData = ctx.pendingTurnComplete.get(sessionId);
+          if (!pendingData)
+            return;
+          const currentTask = ctx.tasks.get(sessionId);
+          if (!currentTask || currentTask.status !== "active") {
+            ctx.pendingTurnComplete.delete(sessionId);
+            return;
+          }
+          handleTurnComplete(ctx, sessionId, currentTask, pendingData).catch((err) => {
+            ctx.log(`Deferred turn-complete replay failed for ${sessionId}: ${err}`);
+          });
+        }, delayMs);
+        deferredTurnCompleteTimers.set(sessionId, timer);
+      }
+      ctx.log(`Suppressing turn-complete for "${taskCtx.label}" — ` + `${Math.round(elapsed / 1000)}s since last input (cooldown ${POST_SEND_COOLDOWN_MS / 1000}s)`);
+      return;
+    }
+  }
+  const deferredTimer = deferredTurnCompleteTimers.get(sessionId);
+  if (deferredTimer) {
+    clearTimeout(deferredTimer);
+    deferredTurnCompleteTimers.delete(sessionId);
+  }
+  ctx.pendingTurnComplete.delete(sessionId);
   ctx.inFlightDecisions.add(sessionId);
   try {
     ctx.log(`Turn complete for "${taskCtx.label}" — assessing whether task is done`);
@@ -1207,10 +1262,11 @@ 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, deferredTurnCompleteTimers;
 var init_swarm_decision_loop = __esm(() => {
   init_ansi_utils();
   init_swarm_event_triage();
+  deferredTurnCompleteTimers = new Map;
 });
 
 // src/actions/finalize-workspace.ts
@@ -2230,13 +2286,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 +3197,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();
@@ -3162,6 +3221,7 @@ async function scanIdleSessions(ctx) {
       if (!session) {
         ctx.log(`Idle watchdog: "${taskCtx.label}" — PTY session no longer exists, marking as stopped`);
         taskCtx.status = "stopped";
+        taskCtx.stoppedAt = now;
         taskCtx.decisions.push({
           timestamp: now,
           event: "idle_watchdog",
@@ -3205,6 +3265,7 @@ async function scanIdleSessions(ctx) {
     if (taskCtx.idleCheckCount >= MAX_IDLE_CHECKS) {
       ctx.log(`Idle watchdog: force-stopping "${taskCtx.label}" after ${MAX_IDLE_CHECKS} checks`);
       taskCtx.status = "stopped";
+      taskCtx.stoppedAt = now;
       taskCtx.decisions.push({
         timestamp: now,
         event: "idle_watchdog",
@@ -3339,6 +3400,7 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
 var UNREGISTERED_BUFFER_MS = 2000;
 var IDLE_SCAN_INTERVAL_MS = 60 * 1000;
 var PAUSE_TIMEOUT_MS = 30000;
+var STOPPED_RECOVERY_WINDOW_MS = 90000;
 
 class SwarmCoordinator {
   static serviceType = "SWARM_COORDINATOR";
@@ -3439,6 +3501,7 @@ class SwarmCoordinator {
     this.pendingDecisions.clear();
     this.inFlightDecisions.clear();
     this.pendingTurnComplete.clear();
+    clearDeferredTurnCompleteTimers();
     this.lastBlockedPromptFingerprint.clear();
     this.pendingBlocked.clear();
     this.unregisteredBuffer.clear();
@@ -3620,8 +3683,21 @@ class SwarmCoordinator {
       }
       return;
     }
+    let recoveredFromStopped = false;
     if (taskCtx.status === "stopped" || taskCtx.status === "error" || taskCtx.status === "completed") {
-      if (event !== "stopped" && event !== "error") {
+      if (taskCtx.status === "stopped" && event === "task_complete") {
+        const stoppedAt = taskCtx.stoppedAt ?? 0;
+        const ageMs = Date.now() - stoppedAt;
+        if (stoppedAt > 0 && ageMs <= STOPPED_RECOVERY_WINDOW_MS) {
+          this.log(`Recovering "${taskCtx.label}" from stopped on late task_complete (${Math.round(ageMs / 1000)}s old)`);
+          taskCtx.status = "active";
+          recoveredFromStopped = true;
+        } else {
+          this.log(`Ignoring "${event}" for ${taskCtx.label} (status: stopped, age=${Math.round(ageMs / 1000)}s)`);
+          return;
+        }
+      }
+      if (!recoveredFromStopped && event !== "stopped" && event !== "error") {
         this.log(`Ignoring "${event}" for ${taskCtx.label} (status: ${taskCtx.status})`);
         return;
       }
@@ -3672,6 +3748,7 @@ class SwarmCoordinator {
       case "stopped":
         if (taskCtx.status !== "completed" && taskCtx.status !== "error") {
           taskCtx.status = "stopped";
+          taskCtx.stoppedAt = Date.now();
         }
         this.inFlightDecisions.delete(sessionId);
         this.broadcast({
@@ -3822,6 +3899,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 +4001,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 +4234,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 +4276,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 +4287,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 +4363,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 +4402,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 +4573,7 @@ class PTYService {
     return this.metricsTracker.getAll();
   }
   log(message) {
-    logger2.debug(`[PTYService] ${message}`);
+    logger3.debug(`[PTYService] ${message}`);
   }
 }
 
@@ -4459,7 +4619,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 +4732,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 +4784,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,11 +4832,13 @@ 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
+import { logger as elizaLogger } from "@elizaos/core";
 var QUERY_TIMEOUT_MS = 5000;
+var SLOW_PATH_BUDGET_MS = 15000;
 function withTimeout2(promise, ms) {
   return Promise.race([
     promise,
@@ -4749,12 +4911,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
@@ -4762,18 +4924,37 @@ async function queryPastExperience(runtime, options = {}) {
     if (!result.trajectories || result.trajectories.length === 0)
       return [];
     const experiences = [];
+    const slowPathDeadline = Date.now() + SLOW_PATH_BUDGET_MS;
     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);
-      if (!detail?.steps)
-        continue;
-      const metadata = detail.metadata;
+      const metadata = summary.metadata;
+      const metadataInsights = Array.isArray(metadata?.insights) ? metadata.insights.filter((value) => typeof value === "string" && value.trim().length > 0).slice(0, 50) : [];
       const decisionType = metadata?.orchestrator?.decisionType ?? "unknown";
       const taskLabel = metadata?.orchestrator?.taskLabel ?? "";
       const trajectoryRepo = metadata?.orchestrator?.repo;
       if (repo && (!trajectoryRepo || trajectoryRepo !== repo))
         continue;
+      if (metadataInsights.length > 0) {
+        elizaLogger.debug(`[trajectory-feedback] Fast path: ${metadataInsights.length} insight(s) from metadata for ${summary.id}`);
+        for (const insight of metadataInsights) {
+          experiences.push({
+            timestamp: summary.startTime,
+            decisionType,
+            taskLabel,
+            insight
+          });
+        }
+        continue;
+      }
+      if (Date.now() > slowPathDeadline) {
+        elizaLogger.debug(`[trajectory-feedback] Slow path budget exhausted; stopping detail loads`);
+        break;
+      }
+      elizaLogger.debug(`[trajectory-feedback] Slow path: loading full detail for ${summary.id} (no metadata insights)`);
+      const detail = await withTimeout2(logger5.getTrajectoryDetail(summary.id), QUERY_TIMEOUT_MS).catch(() => null);
+      if (!detail?.steps)
+        continue;
       for (const step of detail.steps) {
         if (!step.llmCalls)
           continue;
@@ -4806,7 +4987,7 @@ async function queryPastExperience(runtime, options = {}) {
     }
     return Array.from(seen.values()).sort((a, b) => b.timestamp - a.timestamp).slice(0, maxEntries);
   } catch (err) {
-    console.error("[trajectory-feedback] Failed to query past experience:", err);
+    elizaLogger.error(`[trajectory-feedback] Failed to query past experience: ${err}`);
     return [];
   }
 }
@@ -4843,7 +5024,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 +5069,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 +5082,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 +5169,7 @@ ${taskList}
     }));
     return result?.trim() || "";
   } catch (err) {
-    logger5.warn(`Swarm context generation failed: ${err}`);
+    logger6.warn(`Swarm context generation failed: ${err}`);
     return "";
   }
 }
@@ -5160,7 +5341,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 +5373,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 +5433,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 +5450,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 +5466,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 +5485,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 +5526,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 +5707,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 +5786,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) {
@@ -6495,8 +6676,143 @@ class CodingWorkspaceService {
   }
 }
 // src/api/agent-routes.ts
+import { access, readFile as readFile3, realpath, rm } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import * as os4 from "node:os";
 import * as path6 from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var PREFLIGHT_DONE = new Set;
+var PREFLIGHT_INFLIGHT = new Map;
+function shouldAutoPreflight() {
+  if (process.env.PARALLAX_BENCHMARK_PREFLIGHT_AUTO === "1")
+    return true;
+  return false;
+}
+function isPathInside(parent, candidate) {
+  return candidate === parent || candidate.startsWith(`${parent}${path6.sep}`);
+}
+async function resolveSafeVenvPath(workdir, venvDirRaw) {
+  const venvDir = venvDirRaw.trim();
+  if (!venvDir) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must be non-empty");
+  }
+  if (path6.isAbsolute(venvDir)) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must be relative to workdir");
+  }
+  const normalized = path6.normalize(venvDir);
+  if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path6.sep}`)) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must stay within workdir");
+  }
+  const workdirResolved = path6.resolve(workdir);
+  const workdirReal = await realpath(workdirResolved);
+  const resolved = path6.resolve(workdirReal, normalized);
+  if (!isPathInside(workdirReal, resolved)) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV resolves outside workdir");
+  }
+  if (resolved === workdirReal) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must not resolve to workdir root");
+  }
+  try {
+    const resolvedReal = await realpath(resolved);
+    if (!isPathInside(workdirReal, resolvedReal) || resolvedReal === workdirReal) {
+      throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV resolves outside workdir");
+    }
+  } catch (err) {
+    const maybeErr = err;
+    if (maybeErr?.code !== "ENOENT")
+      throw err;
+    const parentReal = await realpath(path6.dirname(resolved));
+    if (!isPathInside(workdirReal, parentReal)) {
+      throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV parent resolves outside workdir");
+    }
+  }
+  return resolved;
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveRequirementsPath(workdir) {
+  const workdirReal = await realpath(path6.resolve(workdir));
+  const candidates = [
+    path6.join(workdir, "apps", "api", "requirements.txt"),
+    path6.join(workdir, "requirements.txt")
+  ];
+  for (const candidate of candidates) {
+    if (!await fileExists(candidate))
+      continue;
+    try {
+      const candidateReal = await realpath(candidate);
+      if (isPathInside(workdirReal, candidateReal))
+        return candidateReal;
+    } catch {}
+  }
+  return null;
+}
+async function fingerprintRequirementsFile(requirementsPath) {
+  const file = await readFile3(requirementsPath);
+  return createHash("sha256").update(file).digest("hex");
+}
+async function runBenchmarkPreflight(workdir) {
+  if (!shouldAutoPreflight())
+    return;
+  const requirementsPath = await resolveRequirementsPath(workdir);
+  if (!requirementsPath)
+    return;
+  const requirementsFingerprint = await fingerprintRequirementsFile(requirementsPath);
+  const mode = process.env.PARALLAX_BENCHMARK_PREFLIGHT_MODE?.toLowerCase() === "warm" ? "warm" : "cold";
+  const venvDir = process.env.PARALLAX_BENCHMARK_PREFLIGHT_VENV || ".benchmark-venv";
+  const venvPath = await resolveSafeVenvPath(workdir, venvDir);
+  const pythonInVenv = path6.join(venvPath, process.platform === "win32" ? "Scripts" : "bin", process.platform === "win32" ? "python.exe" : "python");
+  const key = `${workdir}::${mode}::${venvPath}::${requirementsFingerprint}`;
+  if (PREFLIGHT_DONE.has(key)) {
+    if (await fileExists(pythonInVenv))
+      return;
+    PREFLIGHT_DONE.delete(key);
+  }
+  const existing = PREFLIGHT_INFLIGHT.get(key);
+  if (existing) {
+    await existing;
+    return;
+  }
+  const run = (async () => {
+    const pythonCommand = process.platform === "win32" ? "python" : "python3";
+    if (mode === "cold") {
+      await rm(venvPath, { recursive: true, force: true });
+    }
+    const hasVenv = await fileExists(pythonInVenv);
+    if (!hasVenv) {
+      await execFileAsync(pythonCommand, ["-m", "venv", venvPath], {
+        cwd: workdir,
+        timeout: 120000,
+        maxBuffer: 8 * 1024 * 1024
+      });
+    }
+    await execFileAsync(pythonInVenv, ["-m", "pip", "install", "--upgrade", "pip"], {
+      cwd: workdir,
+      timeout: 300000,
+      maxBuffer: 8 * 1024 * 1024
+    });
+    await execFileAsync(pythonInVenv, ["-m", "pip", "install", "-r", requirementsPath], {
+      cwd: workdir,
+      timeout: 600000,
+      maxBuffer: 16 * 1024 * 1024
+    });
+    PREFLIGHT_DONE.add(key);
+  })();
+  PREFLIGHT_INFLIGHT.set(key, run);
+  try {
+    await run;
+  } finally {
+    PREFLIGHT_INFLIGHT.delete(key);
+  }
+}
 async function handleAgentRoutes(req, res, pathname, ctx) {
   const method = req.method?.toUpperCase();
   if (method === "GET" && pathname === "/api/coding-agents/preflight") {
@@ -6624,19 +6940,25 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
         metadata
       } = body;
       const workspaceBaseDir = path6.join(os4.homedir(), ".milady", "workspaces");
-      const allowedPrefixes = [
-        path6.resolve(workspaceBaseDir),
-        path6.resolve(process.cwd())
-      ];
+      const workspaceBaseDirResolved = path6.resolve(workspaceBaseDir);
+      const cwdResolved = path6.resolve(process.cwd());
+      const workspaceBaseDirReal = await realpath(workspaceBaseDirResolved).catch(() => workspaceBaseDirResolved);
+      const cwdReal = await realpath(cwdResolved).catch(() => cwdResolved);
+      const allowedPrefixes = [workspaceBaseDirReal, cwdReal];
       let workdir = rawWorkdir;
       if (workdir) {
         const resolved = path6.resolve(workdir);
-        const isAllowed = allowedPrefixes.some((prefix2) => resolved === prefix2 || resolved.startsWith(prefix2 + path6.sep));
+        const resolvedReal = await realpath(resolved).catch(() => null);
+        if (!resolvedReal) {
+          sendError(res, "workdir must exist", 403);
+          return true;
+        }
+        const isAllowed = allowedPrefixes.some((prefix2) => resolvedReal === prefix2 || resolvedReal.startsWith(prefix2 + path6.sep));
         if (!isAllowed) {
           sendError(res, "workdir must be within workspace base directory or cwd", 403);
           return true;
         }
-        workdir = resolved;
+        workdir = resolvedReal;
       }
       const activeSessions = await ctx.ptyService.listSessions();
       const maxSessions = 8;
@@ -6644,6 +6966,13 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
         sendError(res, `Concurrent session limit reached (${maxSessions})`, 429);
         return true;
       }
+      if (workdir) {
+        try {
+          await runBenchmarkPreflight(workdir);
+        } catch (preflightError) {
+          console.warn(`[coding-agent] benchmark preflight failed for ${workdir}:`, preflightError);
+        }
+      }
       const credentials = {
         anthropicKey: ctx.runtime.getSetting("ANTHROPIC_API_KEY"),
         openaiKey: ctx.runtime.getSetting("OPENAI_API_KEY"),
@@ -7370,5 +7699,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=1AF5CF89CDA1169464756E2164756E21
+//# debugId=A818F3DE8DCF48E664756E2164756E21
 //# sourceMappingURL=index.js.map