@elizaos/plugin-agent-orchestrator 0.3.12 → 0.3.14

package/dist/index.js

@@ -537,6 +537,7 @@ __export(exports_swarm_decision_loop, {
   handleBlocked: () => handleBlocked,
   handleAutonomousDecision: () => handleAutonomousDecision,
   executeDecision: () => executeDecision,
+  clearDeferredTurnCompleteTimers: () => clearDeferredTurnCompleteTimers,
   checkAllTasksComplete: () => checkAllTasksComplete,
   POST_SEND_COOLDOWN_MS: () => POST_SEND_COOLDOWN_MS
 });
@@ -554,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,
@@ -733,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,
@@ -958,6 +974,8 @@ 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);
@@ -966,10 +984,35 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
   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`);
@@ -1219,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, POST_SEND_COOLDOWN_MS = 15000;
+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
@@ -3177,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",
@@ -3220,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",
@@ -3354,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";
@@ -3454,6 +3501,7 @@ class SwarmCoordinator {
     this.pendingDecisions.clear();
     this.inFlightDecisions.clear();
     this.pendingTurnComplete.clear();
+    clearDeferredTurnCompleteTimers();
     this.lastBlockedPromptFingerprint.clear();
     this.pendingBlocked.clear();
     this.unregisteredBuffer.clear();
@@ -3635,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;
       }
@@ -3687,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({
@@ -4774,7 +4836,9 @@ import {
   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,
@@ -4860,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(logger5.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;
@@ -4904,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 [];
   }
 }
@@ -4998,8 +5081,8 @@ ${preview}` : `Agent "${label}" completed the task.`
     if ((event === "stopped" || event === "task_complete" || event === "error") && scratchDir) {
       const wsService = runtime.getService("CODING_WORKSPACE_SERVICE");
       if (wsService) {
-        wsService.removeScratchDir(scratchDir).catch((err) => {
-          logger5.warn(`[START_CODING_TASK] Failed to cleanup scratch dir for "${label}": ${err}`);
+        wsService.registerScratchWorkspace(sessionId, scratchDir, label, event).catch((err) => {
+          logger5.warn(`[START_CODING_TASK] Failed to register scratch workspace for "${label}": ${err}`);
         });
       }
     }
@@ -6046,6 +6129,7 @@ var activeWorkspaceContextProvider = {
 // src/services/workspace-service.ts
 import * as os3 from "node:os";
 import * as path5 from "node:path";
+import * as fs3 from "node:fs/promises";
 import {
   CredentialService,
   GitHubPatClient as GitHubPatClient2,
@@ -6327,6 +6411,8 @@ class CodingWorkspaceService {
   serviceConfig;
   workspaces = new Map;
   labels = new Map;
+  scratchBySession = new Map;
+  scratchCleanupTimers = new Map;
   eventCallbacks = [];
   authPromptCallback = null;
   constructor(runtime, config = {}) {
@@ -6384,6 +6470,10 @@ class CodingWorkspaceService {
     });
   }
   async stop() {
+    for (const timer of this.scratchCleanupTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.scratchCleanupTimers.clear();
     for (const [id] of this.workspaces) {
       try {
         await this.removeWorkspace(id);
@@ -6583,6 +6673,89 @@ class CodingWorkspaceService {
   async removeScratchDir(dirPath) {
     return removeScratchDir(dirPath, this.serviceConfig.baseDir, (msg) => this.log(msg));
   }
+  listScratchWorkspaces() {
+    return Array.from(this.scratchBySession.values()).sort((a, b) => b.terminalAt - a.terminalAt);
+  }
+  async registerScratchWorkspace(sessionId, dirPath, label, terminalEvent) {
+    const now = Date.now();
+    const existing = this.scratchBySession.get(sessionId);
+    const base = existing ?? {
+      sessionId,
+      label,
+      path: dirPath,
+      createdAt: now,
+      terminalAt: now,
+      terminalEvent,
+      status: "pending_decision"
+    };
+    const policy = this.getScratchRetentionPolicy();
+    if (policy === "ephemeral") {
+      await this.removeScratchDir(dirPath);
+      this.scratchBySession.delete(sessionId);
+      this.clearScratchCleanupTimer(sessionId);
+      return null;
+    }
+    const record = {
+      ...base,
+      label,
+      path: dirPath,
+      terminalAt: now,
+      terminalEvent,
+      status: policy === "persistent" ? "kept" : "pending_decision",
+      expiresAt: undefined
+    };
+    this.scratchBySession.set(sessionId, record);
+    if (record.status === "pending_decision") {
+      const ttlMs = this.getScratchDecisionTtlMs();
+      record.expiresAt = now + ttlMs;
+      this.scheduleScratchCleanup(sessionId, ttlMs);
+    } else {
+      this.clearScratchCleanupTimer(sessionId);
+    }
+    return record;
+  }
+  async keepScratchWorkspace(sessionId) {
+    const record = this.requireScratchWorkspace(sessionId);
+    const next = {
+      ...record,
+      status: "kept",
+      expiresAt: undefined
+    };
+    this.scratchBySession.set(sessionId, next);
+    this.clearScratchCleanupTimer(sessionId);
+    return next;
+  }
+  async deleteScratchWorkspace(sessionId) {
+    const record = this.requireScratchWorkspace(sessionId);
+    await this.removeScratchDir(record.path);
+    this.scratchBySession.delete(sessionId);
+    this.clearScratchCleanupTimer(sessionId);
+  }
+  async promoteScratchWorkspace(sessionId, name) {
+    const record = this.requireScratchWorkspace(sessionId);
+    const baseDir = this.serviceConfig.baseDir;
+    const suggestedName = this.sanitizeWorkspaceName(name || record.label);
+    const targetPath = await this.allocatePromotedPath(baseDir, suggestedName);
+    try {
+      await fs3.rename(record.path, targetPath);
+    } catch (error) {
+      const isExdev = typeof error === "object" && error !== null && "code" in error && error.code === "EXDEV";
+      if (!isExdev)
+        throw error;
+      await fs3.cp(record.path, targetPath, { recursive: true });
+      await fs3.access(targetPath);
+      await fs3.rm(record.path, { recursive: true, force: true });
+    }
+    const next = {
+      ...record,
+      path: targetPath,
+      status: "promoted",
+      expiresAt: undefined
+    };
+    this.scratchBySession.set(sessionId, next);
+    this.clearScratchCleanupTimer(sessionId);
+    return next;
+  }
   async gcOrphanedWorkspaces() {
     return gcOrphanedWorkspaces(this.serviceConfig.baseDir, this.serviceConfig.workspaceTtlMs ?? 24 * 60 * 60 * 1000, new Set(this.workspaces.keys()), (msg) => this.log(msg));
   }
@@ -6591,10 +6764,213 @@ class CodingWorkspaceService {
       console.log(`[CodingWorkspaceService] ${message}`);
     }
   }
+  getScratchRetentionPolicy() {
+    const setting = this.runtime.getSetting("PARALLAX_SCRATCH_RETENTION") ?? process.env.PARALLAX_SCRATCH_RETENTION;
+    const normalized = setting?.trim().toLowerCase();
+    if (normalized === "ephemeral")
+      return "ephemeral";
+    if (normalized === "persistent" || normalized === "keep") {
+      return "persistent";
+    }
+    return "pending_decision";
+  }
+  getScratchDecisionTtlMs() {
+    const setting = this.runtime.getSetting("PARALLAX_SCRATCH_DECISION_TTL_MS");
+    const parsed = Number(setting ?? process.env.PARALLAX_SCRATCH_DECISION_TTL_MS);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
+    return 24 * 60 * 60 * 1000;
+  }
+  requireScratchWorkspace(sessionId) {
+    const record = this.scratchBySession.get(sessionId);
+    if (!record) {
+      throw new Error(`Scratch workspace for session ${sessionId} not found`);
+    }
+    return record;
+  }
+  clearScratchCleanupTimer(sessionId) {
+    const timer = this.scratchCleanupTimers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.scratchCleanupTimers.delete(sessionId);
+    }
+  }
+  scheduleScratchCleanup(sessionId, ttlMs) {
+    this.clearScratchCleanupTimer(sessionId);
+    const timer = setTimeout(async () => {
+      try {
+        const record = this.scratchBySession.get(sessionId);
+        if (!record || record.status !== "pending_decision")
+          return;
+        await this.removeScratchDir(record.path);
+      } catch (error) {
+        console.warn(`[CodingWorkspaceService] scratch cleanup failed for ${sessionId}: ${String(error)}`);
+      } finally {
+        this.scratchBySession.delete(sessionId);
+        this.scratchCleanupTimers.delete(sessionId);
+      }
+    }, ttlMs);
+    this.scratchCleanupTimers.set(sessionId, timer);
+  }
+  sanitizeWorkspaceName(raw) {
+    const compact = raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    return compact || `scratch-${Date.now().toString(36)}`;
+  }
+  async allocatePromotedPath(baseDir, baseName) {
+    const baseResolved = path5.resolve(baseDir);
+    for (let i = 0;i < 1000; i++) {
+      const candidateName = i === 0 ? baseName : `${baseName}-${i}`;
+      const candidate = path5.resolve(baseResolved, candidateName);
+      if (candidate !== baseResolved && !candidate.startsWith(`${baseResolved}${path5.sep}`)) {
+        continue;
+      }
+      try {
+        await fs3.access(candidate);
+      } catch {
+        return candidate;
+      }
+    }
+    throw new Error("Unable to allocate promoted workspace path");
+  }
 }
 // src/api/agent-routes.ts
+import { access as access2, readFile as readFile3, realpath, rm as rm2 } 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 access2(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 rm2(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") {
@@ -6618,6 +6994,44 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
     sendJson(res, ctx.ptyService.getAgentMetrics());
     return true;
   }
+  if (method === "GET" && pathname === "/api/coding-agents/scratch") {
+    if (!ctx.workspaceService) {
+      sendError(res, "Workspace Service not available", 503);
+      return true;
+    }
+    sendJson(res, ctx.workspaceService.listScratchWorkspaces());
+    return true;
+  }
+  const scratchActionMatch = pathname.match(/^\/api\/coding-agents\/([^/]+)\/scratch\/(keep|delete|promote)$/);
+  if (method === "POST" && scratchActionMatch) {
+    if (!ctx.workspaceService) {
+      sendError(res, "Workspace Service not available", 503);
+      return true;
+    }
+    const sessionId = scratchActionMatch[1];
+    const action = scratchActionMatch[2];
+    try {
+      if (action === "keep") {
+        const scratch2 = await ctx.workspaceService.keepScratchWorkspace(sessionId);
+        sendJson(res, { success: true, scratch: scratch2 });
+        return true;
+      }
+      if (action === "delete") {
+        await ctx.workspaceService.deleteScratchWorkspace(sessionId);
+        sendJson(res, { success: true, deleted: true, sessionId });
+        return true;
+      }
+      const body = await parseBody(req);
+      const promoteName = typeof body.name === "string" ? body.name : undefined;
+      const scratch = await ctx.workspaceService.promoteScratchWorkspace(sessionId, promoteName);
+      sendJson(res, { success: true, scratch });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message.includes("not found") ? 404 : 500;
+      sendError(res, message, status);
+    }
+    return true;
+  }
   if (method === "GET" && pathname === "/api/coding-agents/workspace-files") {
     if (!ctx.ptyService) {
       sendError(res, "PTY Service not available", 503);
@@ -6722,19 +7136,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;
@@ -6742,6 +7162,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"),
@@ -7366,7 +7793,7 @@ async function handleWorkspaceRoutes(req, res, pathname, ctx) {
 // src/api/routes.ts
 var MAX_BODY_SIZE = 1024 * 1024;
 async function parseBody(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let body = "";
     let size = 0;
     req.on("data", (chunk) => {
@@ -7380,7 +7807,7 @@ async function parseBody(req) {
     });
     req.on("end", () => {
       try {
-        resolve5(body ? JSON.parse(body) : {});
+        resolve6(body ? JSON.parse(body) : {});
       } catch {
         reject(new Error("Invalid JSON body"));
       }
@@ -7468,5 +7895,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=4383E51DF7A1F4A764756E2164756E21
+//# debugId=C0B3DB8984D7685C64756E2164756E21
 //# sourceMappingURL=index.js.map