@elizaos/plugin-agent-orchestrator 0.3.19 → 0.4.1

package/dist/index.js

@@ -34,8 +34,14 @@ function cleanForChat(raw) {
       return false;
     if (STATUS_LINE.test(trimmed))
       return false;
+    if (TOOL_MARKER_LINE.test(trimmed))
+      return false;
+    if (GIT_NOISE_LINE.test(trimmed))
+      return false;
     if (!/[a-zA-Z0-9]/.test(trimmed))
       return false;
+    if (trimmed.length <= 3)
+      return false;
     return true;
   }).map((line) => line.replace(/ {2,}/g, " ").trim()).filter((line) => line.length > 0).join(`
 `).replace(/\n{3,}/g, `
@@ -83,7 +89,7 @@ function captureTaskResponse(sessionId, buffers, markers) {
   return cleanForChat(responseLines.join(`
 `));
 }
-var CURSOR_MOVEMENT, CURSOR_POSITION, ERASE, OSC, ALL_ANSI, CONTROL_CHARS, ORPHAN_SGR, LONG_SPACES, TUI_DECORATIVE, LOADING_LINE, STATUS_LINE;
+var CURSOR_MOVEMENT, CURSOR_POSITION, ERASE, OSC, ALL_ANSI, CONTROL_CHARS, ORPHAN_SGR, LONG_SPACES, TUI_DECORATIVE, LOADING_LINE, STATUS_LINE, TOOL_MARKER_LINE, GIT_NOISE_LINE;
 var init_ansi_utils = __esm(() => {
   CURSOR_MOVEMENT = /\x1b\[\d*[CDABGdEF]/g;
   CURSOR_POSITION = /\x1b\[\d*(?:;\d+)?[Hf]/g;
@@ -94,8 +100,10 @@ var init_ansi_utils = __esm(() => {
   ORPHAN_SGR = /\[[\d;]*m/g;
   LONG_SPACES = / {3,}/g;
   TUI_DECORATIVE = /[│╭╰╮╯─═╌║╔╗╚╝╠╣╦╩╬┌┐└┘├┤┬┴┼●○❮❯▶◀⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⣾⣽⣻⢿⡿⣟⣯⣷✽✻✶✳✢⏺←→↑↓⬆⬇◆▪▫■□▲△▼▽◈⟨⟩⌘⏎⏏⌫⌦⇧⇪⌥·⎿✔◼]/g;
-  LOADING_LINE = /^\s*(?:thinking|Forging|Shenaniganing|Inferring|Cooking|Brewing|Loading|Scheming|Pondering|Conjuring|Manifesting|Reflecting|Synthesizing|Vibing|Summoning|Compiling|processing|Elucidating|Cogitat\w+|Bak\w+)(?:…|\.{3})?(?:\s*\(.*\))?\s*$/i;
+  LOADING_LINE = /^\s*(?:[A-Z][a-z]+(?:-[a-z]+)?(?:ing|ed)\w*|thinking|Loading|processing)(?:…|\.{3})(?:\s*\(.*\)|\s+for\s+\d+[smh](?:\s+\d+[smh])*)?\s*$|^\s*(?:[A-Z][a-z]+(?:-[a-z]+)?(?:ing|ed)\w*|thinking|Loading|processing)\s+for\s+\d+[smh](?:\s+\d+[smh])*\s*$/;
   STATUS_LINE = /^\s*(?:\d+[smh]\s+\d+s?\s*·|↓\s*[\d.]+k?\s*tokens|·\s*↓|esc\s+to\s+interrupt|[Uu]pdate available|ate available|Run:\s+brew|brew\s+upgrade|\d+\s+files?\s+\+\d+\s+-\d+|ctrl\+\w|\+\d+\s+lines|Wrote\s+\d+\s+lines\s+to|\?\s+for\s+shortcuts|Cooked for|Baked for|Cogitated for)/i;
+  TOOL_MARKER_LINE = /^\s*(?:Bash|Write|Read|Edit|Glob|Grep|Search|TodoWrite|Agent)\s*\(.*\)\s*$/;
+  GIT_NOISE_LINE = /^\s*(?:On branch\s+\w|Your branch is|modified:|new file:|deleted:|renamed:|Untracked files:|Changes (?:not staged|to be committed)|\d+\s+files?\s+changed.*(?:insertion|deletion))/i;
 });
 
 // src/services/trajectory-context.ts
@@ -191,8 +199,7 @@ ${recentOutput.slice(-3000)}
 ` + `- For Y/n confirmations that align with the original task, respond "y".
 ` + `- For design questions or choices that could go either way, escalate.
 ` + `- For error recovery prompts, try to respond if the path forward is clear.
-` + `- If the output shows a PR was just created (e.g. "Created pull request #N"), do NOT use "complete" yet. ` + `Instead 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".
-` + `- Only use "complete" if the agent confirmed it verified ALL test plan items after creating the PR.
+` + `- If the output shows a PR was just created (e.g. "Created pull request #N"), use "complete" — the task is done.
 ` + `- If the agent is asking for information that was NOT provided in the original task ` + `(e.g. which repository to use, project requirements, credentials), ESCALATE. ` + `The coordinator does not have this information — the human must provide it.
 ` + `- When in doubt, escalate — it's better to ask the human than to make a wrong choice.
 ` + `- If the agent's output reveals a significant decision that sibling agents should know about ` + `(e.g. chose a library, designed an API shape, picked a UI pattern, established a writing style, ` + `narrowed a research scope, made any choice that affects the shared project), ` + `include "keyDecision" with a brief one-line summary. Skip this for routine tool approvals.
@@ -260,35 +267,24 @@ Output from this turn:
 ${turnOutput.slice(-3000)}
 ---
 
-` + `The agent completed a turn. Decide if the OVERALL task is done or if more work is needed.
-
-` + `IMPORTANT: Coding agents work in multiple turns. A single turn completing does NOT mean ` + `the task is done. You must verify that EVERY objective in the original task has been addressed ` + `in the output before declaring "complete".
-
-` + `Your options:
-
-` + `1. "respond" — The agent finished a step but the overall task is NOT done yet. ` + `Send a follow-up instruction to continue. Set "response" to the next instruction ` + `(e.g. "Now run the tests", "Create a PR with these changes", "Continue with the next part"). ` + `THIS IS THE DEFAULT — most turns are intermediate steps, not the final result.
-
-` + `2. "complete" — The original task objectives have ALL been fully met. For repo-based tasks, ` + `this means code was written, changes were committed, pushed, AND a pull request was created. ` + `Only use this when you can point to specific evidence in the output for EVERY objective ` + `(e.g. "Created pull request #N" in the output).
-
-` + `3. "escalate" — Something looks wrong or you're unsure whether the task is complete. ` + `Let the human decide.
-
-` + `4. "ignore" — Should not normally be used here.
+` + `The agent completed a turn. Decide if the task is done or needs more work.
 
-` + `Guidelines:
-` + `- 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.
-` + `- A PR being created does NOT mean the task is done — check that the PR covers ALL requested changes.
-` + `- If the task mentions multiple features/fixes, verify EACH one is addressed, not just the first.
-` + `- If the agent only analyzed code or read files, it hasn't done the actual work yet — send a follow-up.
-` + `- If the agent wrote code but didn't test it and testing seems appropriate, ask it to run tests.
-` + `- If the output shows errors or failed tests, send a follow-up to fix them.
-` + `- 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".
-` + `- 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".
-` + `- 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 — use judgment.
-` + `- Keep follow-up instructions concise and specific.
-` + `- When asking agents to verify work, prefer CLI tools (gh, curl, cat, git diff, etc.) over ` + `browser automation. Browser tools may not be available in headless environments and can cause delays.
-` + `- Default to "respond" — only use "complete" when you're certain ALL work is done.
-` + `- If the agent's output reveals a significant decision that sibling agents should know about ` + `(e.g. chose a library, designed an API shape, picked a UI pattern, established a writing style, ` + `narrowed a research scope, made any choice that affects the shared project), ` + `include "keyDecision" with a brief one-line summary. Skip this for routine tool approvals.
-` + `- Look for explicit "DECISION:" markers in the agent's output — these are the agent deliberately ` + `surfacing design choices. Always capture these as keyDecision.
+` + `Options:
+` + `1. "complete" — The task objectives have been met.
+` + `   - For repo tasks: ONLY when a PR creation signal appears ("Created pull request #N"). ` + `A generic "done" or "finished" statement is NOT sufficient for repo tasks — a PR must exist.
+` + `   - For scratch/research tasks (no repo): when the agent has produced its deliverable.
+` + `2. "respond" — The agent needs to do more work.
+` + `3. "escalate" — Something is wrong. Let the human decide.
+` + `4. "ignore" — The agent is still working (e.g., spinner text like "Germinating...", "Frosting..."). ` + `Wait for the next turn.
+
+` + `CRITICAL RULES:
+` + `- For repo tasks: use "complete" ONLY when "Created pull request #N" appears in output.
+` + `- For scratch/research tasks: use "complete" when the agent delivers its output.
+` + `- Do NOT ask the agent to review, verify, or re-check work it already completed.
+` + `- If output is only spinner text, use "ignore" and wait for the next turn.
+` + `- Use "respond" when the agent hasn't started, or when code was written but not yet committed/pushed/PR'd.
+
+` + `If the agent's output reveals a significant decision, include "keyDecision" with a brief summary.
 
 ` + `Respond with ONLY a JSON object:
 ` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}`;
@@ -322,7 +318,7 @@ ${recentOutput.slice(-3000)}
 ` + `- For tool approvals / Y/n that align with the task, respond "y" or keys:["enter"].
 ` + `- If the prompt asks for info NOT in the original task, escalate.
 ` + `- Decline access to paths outside ${taskCtx.workdir}.
-` + `- If a PR was just created, respond to review & verify test plan items before completing.
+` + `- If a PR was just created, the task is done — use "complete".
 ` + `- When in doubt, escalate.
 
 ` + `If the agent's output reveals a significant decision that sibling agents should know about, include "keyDecision" with a brief summary.
@@ -353,16 +349,14 @@ ${turnOutput.slice(-3000)}
 
 ` + `Options:
 ` + `- "respond" — send a follow-up instruction (DEFAULT for intermediate steps)
-` + `- "complete" — ALL task objectives met (code written, committed, PR created & verified)
+` + `- "complete" — For repo tasks: ONLY when "Created pull request #N" appears. ` + `For scratch/research tasks: when the agent delivers its output.
 ` + `- "escalate" — something looks wrong, ask the user
-` + `- "ignore" — should not normally be used here
+` + `- "ignore" — spinner/loading output, agent still working
 
 ` + `Guidelines:
-` + `- Verify evidence for EVERY objective before using "complete".
+` + `- For repo tasks, a generic "done" is NOT enough — require a PR creation signal.
 ` + `- If code was written but not committed/pushed/PR'd, respond with next step.
-` + `- If a PR was just created, respond to review & verify test plan items.
-` + `- When asking agents to verify work, prefer CLI tools (gh, curl, cat, etc.) over browser automation.
-` + `- Default to "respond" — only "complete" when certain ALL work is done.
+` + `- Do NOT ask the agent to re-verify work it already completed.
 ` + `- If the agent's output reveals a significant creative or architectural decision, include "keyDecision" with a brief summary.
 ` + `- Look for explicit "DECISION:" markers in the agent's output — always capture these as keyDecision.
 
@@ -822,6 +816,18 @@ async function executeDecision(ctx, sessionId, decision) {
       const taskCtx = ctx.tasks.get(sessionId);
       if (taskCtx) {
         taskCtx.status = "completed";
+        ctx.history?.append({
+          timestamp: Date.now(),
+          type: "task_completed",
+          sessionId,
+          label: taskCtx.label,
+          agentType: taskCtx.agentType,
+          repo: taskCtx.repo,
+          workdir: taskCtx.workdir,
+          completionSummary: decision.reasoning
+        }).catch((err) => {
+          ctx.log(`Failed to persist task completion for "${taskCtx.label}" (${sessionId}): ${err}`);
+        });
       }
       ctx.broadcast({
         type: "task_complete",
@@ -1022,6 +1028,31 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
       const raw = await fetchRecentOutput(ctx, sessionId);
       turnOutput = cleanForChat(raw);
     }
+    const PR_CREATED_RE = /(?:Created|Opened)\s+pull\s+request\s+#?\d+|gh\s+pr\s+create/i;
+    if (PR_CREATED_RE.test(turnOutput)) {
+      const fastDecision = {
+        action: "complete",
+        reasoning: "PR detected in turn output — task complete."
+      };
+      ctx.log(`Turn assessment for "${taskCtx.label}": complete (fast-path: PR detected in output)`);
+      taskCtx.decisions.push({
+        timestamp: Date.now(),
+        event: "turn_complete",
+        promptText: "Agent finished a turn",
+        decision: "complete",
+        response: "",
+        reasoning: fastDecision.reasoning
+      });
+      recordKeyDecision(ctx, taskCtx.label, fastDecision);
+      ctx.broadcast({
+        type: "turn_assessment",
+        sessionId,
+        timestamp: Date.now(),
+        data: { action: "complete", reasoning: fastDecision.reasoning }
+      });
+      await executeDecision(ctx, sessionId, fastDecision);
+      return;
+    }
     let decision = null;
     const decisionFromPipeline = false;
     const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx), collectSiblings(ctx, sessionId), ctx.sharedDecisions, ctx.getSwarmContext());
@@ -2283,15 +2314,15 @@ var sendToAgentAction = {
 };
 
 // src/actions/spawn-agent.ts
-import * as os from "node:os";
-import * as path2 from "node:path";
+import * as os2 from "node:os";
+import * as path3 from "node:path";
 import {
   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 { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
 import { logger as logger3 } from "@elizaos/core";
 import {
   checkAdapters,
@@ -3103,9 +3134,9 @@ Classification states:
 - For Y/n confirmations that align with the original task, respond "y".
 - For TUI menus, use "keys:enter" for default or "keys:down,enter" for non-default.
 - If the prompt asks for information NOT in the original task, set suggestedResponse to null (this will escalate to the human).
-- If a PR was just created, respond to review & verify test plan items before completing.
+` + `- If a PR was just created, the task is likely done — classify as "task_complete".
 
-Respond with ONLY a JSON object:
+` + `Respond with ONLY a JSON object:
 {"state": "...", "prompt": "...", "suggestedResponse": "..."}`;
 }
 async function classifyAndDecideForCoordinator(ctx) {
@@ -3202,9 +3233,124 @@ init_swarm_decision_loop();
 
 // src/services/swarm-coordinator.ts
 init_ansi_utils();
-init_swarm_decision_loop();
 import { logger } from "@elizaos/core";
 
+// src/services/swarm-history.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path2 from "path";
+var MAX_ENTRIES = 150;
+var TRUNCATE_TO = 100;
+
+class WriteMutex {
+  queue = [];
+  locked = false;
+  async acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    return new Promise((resolve2) => {
+      this.queue.push(resolve2);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+}
+
+class SwarmHistory {
+  filePath;
+  appendCount = 0;
+  mutex = new WriteMutex;
+  constructor(stateDir) {
+    const dir = stateDir || process.env.MILADY_STATE_DIR || process.env.ELIZA_STATE_DIR || path2.join(os.homedir(), ".milady");
+    this.filePath = path2.join(dir, "swarm-history.jsonl");
+  }
+  async append(entry) {
+    await this.mutex.acquire();
+    try {
+      const dir = path2.dirname(this.filePath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.appendFile(this.filePath, `${JSON.stringify(entry)}
+`, "utf-8");
+      this.appendCount++;
+      if (this.appendCount >= MAX_ENTRIES - TRUNCATE_TO) {
+        const content = await fs.readFile(this.filePath, "utf-8");
+        const lineCount = content.split(`
+`).filter((l) => l.trim() !== "").length;
+        if (lineCount > MAX_ENTRIES) {
+          await this.truncateInner(TRUNCATE_TO);
+        }
+      }
+    } catch (err) {
+      console.error("[swarm-history] append failed:", err);
+      throw err;
+    } finally {
+      this.mutex.release();
+    }
+  }
+  async readAll() {
+    try {
+      const content = await fs.readFile(this.filePath, "utf-8");
+      const entries = [];
+      const lines = content.split(`
+`);
+      for (let i = 0;i < lines.length; i++) {
+        if (lines[i].trim() === "")
+          continue;
+        try {
+          entries.push(JSON.parse(lines[i]));
+        } catch {
+          console.warn(`[swarm-history] skipping corrupted line at index ${i} (length=${lines[i].length})`);
+        }
+      }
+      return entries;
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return [];
+      }
+      console.error("[swarm-history] readAll failed:", err);
+      return [];
+    }
+  }
+  async getLastUsedRepo() {
+    const entries = await this.readAll();
+    for (let i = entries.length - 1;i >= 0; i--) {
+      if (entries[i].repo) {
+        return entries[i].repo;
+      }
+    }
+    return;
+  }
+  async truncateInner(maxEntries) {
+    const entries = await this.readAll();
+    if (entries.length === 0) {
+      try {
+        await fs.stat(this.filePath);
+        console.error("[swarm-history] truncate aborted: file exists but readAll returned empty");
+        return;
+      } catch {
+        return;
+      }
+    }
+    const kept = entries.slice(-maxEntries);
+    const content = kept.map((e) => JSON.stringify(e)).join(`
+`) + `
+`;
+    await fs.writeFile(this.filePath, content, "utf-8");
+    this.appendCount = 0;
+  }
+}
+
+// src/services/swarm-coordinator.ts
+init_swarm_decision_loop();
+
 // src/services/swarm-idle-watchdog.ts
 init_ansi_utils();
 init_swarm_decision_loop();
@@ -3397,7 +3543,9 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
 }
 
 // src/services/swarm-coordinator.ts
-var UNREGISTERED_BUFFER_MS = 2000;
+var UNREGISTERED_RETRY_DELAYS = [2000, 4000, 8000, 16000];
+var UNREGISTERED_MAX_TOTAL_MS = 30000;
+var TURN_COMPLETE_COALESCE_MS = 500;
 var IDLE_SCAN_INTERVAL_MS = 60 * 1000;
 var PAUSE_TIMEOUT_MS = 30000;
 var MAX_PRE_BRIDGE_BUFFER = 100;
@@ -3431,6 +3579,10 @@ class SwarmCoordinator {
   pauseBuffer = [];
   preBridgeBroadcastBuffer = [];
   pauseTimeout = null;
+  startedAt = Date.now();
+  unregisteredRetryTimers = new Map;
+  turnCompleteCoalesceTimers = new Map;
+  history = new SwarmHistory;
   constructor(runtime) {
     this.runtime = runtime;
   }
@@ -3515,6 +3667,14 @@ class SwarmCoordinator {
     this.lastBlockedPromptFingerprint.clear();
     this.pendingBlocked.clear();
     this.unregisteredBuffer.clear();
+    for (const timer of this.unregisteredRetryTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.unregisteredRetryTimers.clear();
+    for (const timer of this.turnCompleteCoalesceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.turnCompleteCoalesceTimers.clear();
     this.lastSeenOutput.clear();
     this.lastToolNotification.clear();
     this.agentDecisionCb = null;
@@ -3601,6 +3761,19 @@ class SwarmCoordinator {
       taskDelivered: false,
       lastSeenDecisionIndex: 0
     });
+    if (context.repo) {
+      this._lastUsedRepo = context.repo;
+    }
+    this.history.append({
+      timestamp: Date.now(),
+      type: "task_registered",
+      sessionId,
+      label: context.label,
+      agentType: context.agentType,
+      repo: context.repo,
+      workdir: context.workdir,
+      originalTask: context.originalTask
+    }).catch(() => {});
     this.broadcast({
       type: "task_registered",
       sessionId,
@@ -3611,6 +3784,11 @@ class SwarmCoordinator {
         originalTask: context.originalTask
       }
     });
+    const retryTimer = this.unregisteredRetryTimers.get(sessionId);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.unregisteredRetryTimers.delete(sessionId);
+    }
     const buffered = this.unregisteredBuffer.get(sessionId);
     if (buffered) {
       this.unregisteredBuffer.delete(sessionId);
@@ -3621,6 +3799,7 @@ class SwarmCoordinator {
       }
     }
   }
+  _lastUsedRepo;
   getLastUsedRepo() {
     let latest;
     for (const task of this.tasks.values()) {
@@ -3628,7 +3807,17 @@ class SwarmCoordinator {
         latest = task;
       }
     }
-    return latest?.repo;
+    return latest?.repo ?? this._lastUsedRepo;
+  }
+  async getLastUsedRepoAsync() {
+    const memoryRepo = this.getLastUsedRepo();
+    if (memoryRepo)
+      return memoryRepo;
+    try {
+      return await this.history.getLastUsedRepo();
+    } catch {
+      return;
+    }
   }
   getTaskContext(sessionId) {
     return this.tasks.get(sessionId);
@@ -3636,6 +3825,33 @@ class SwarmCoordinator {
   getAllTaskContexts() {
     return Array.from(this.tasks.values());
   }
+  scheduleUnregisteredRetry(sessionId, attempt) {
+    const delay = UNREGISTERED_RETRY_DELAYS[Math.min(attempt, UNREGISTERED_RETRY_DELAYS.length - 1)];
+    const timer = setTimeout(() => {
+      this.unregisteredRetryTimers.delete(sessionId);
+      const stillBuffered = this.unregisteredBuffer.get(sessionId);
+      if (!stillBuffered || stillBuffered.length === 0)
+        return;
+      const ctx = this.tasks.get(sessionId);
+      if (ctx) {
+        this.unregisteredBuffer.delete(sessionId);
+        for (const entry of stillBuffered) {
+          this.handleSessionEvent(sessionId, entry.event, entry.data).catch(() => {});
+        }
+        return;
+      }
+      const oldest = stillBuffered[0].receivedAt;
+      const totalElapsed = Date.now() - oldest;
+      if (totalElapsed >= UNREGISTERED_MAX_TOTAL_MS) {
+        this.unregisteredBuffer.delete(sessionId);
+        this.log(`Discarding ${stillBuffered.length} buffered events for unregistered session ${sessionId} after ${Math.round(totalElapsed / 1000)}s`);
+        return;
+      }
+      this.log(`Retry ${attempt + 1} for unregistered session ${sessionId} (next in ${delay}ms)`);
+      this.scheduleUnregisteredRetry(sessionId, attempt + 1);
+    }, delay);
+    this.unregisteredRetryTimers.set(sessionId, timer);
+  }
   addSseClient(res) {
     this.sseClients.add(res);
     const snapshot = {
@@ -3681,6 +3897,13 @@ class SwarmCoordinator {
     } catch {}
   }
   async handleSessionEvent(sessionId, event, data) {
+    const tsMatch = sessionId.match(/^pty-(\d+)-/);
+    if (tsMatch) {
+      const sessionCreatedAt = Number(tsMatch[1]);
+      if (sessionCreatedAt < this.startedAt - 60000) {
+        return;
+      }
+    }
     const taskCtx = this.tasks.get(sessionId);
     if (!taskCtx) {
       if (event === "blocked" || event === "task_complete" || event === "error") {
@@ -3690,21 +3913,9 @@ class SwarmCoordinator {
           this.unregisteredBuffer.set(sessionId, buffer);
         }
         buffer.push({ event, data, receivedAt: Date.now() });
-        setTimeout(() => {
-          const stillBuffered = this.unregisteredBuffer.get(sessionId);
-          if (stillBuffered && stillBuffered.length > 0) {
-            const ctx = this.tasks.get(sessionId);
-            if (ctx) {
-              this.unregisteredBuffer.delete(sessionId);
-              for (const entry of stillBuffered) {
-                this.handleSessionEvent(sessionId, entry.event, entry.data).catch(() => {});
-              }
-            } else {
-              this.unregisteredBuffer.delete(sessionId);
-              this.log(`Discarding ${stillBuffered.length} buffered events for unregistered session ${sessionId}`);
-            }
-          }
-        }, UNREGISTERED_BUFFER_MS);
+        if (!this.unregisteredRetryTimers.has(sessionId)) {
+          this.scheduleUnregisteredRetry(sessionId, 0);
+        }
       }
       return;
     }
@@ -3754,7 +3965,20 @@ class SwarmCoordinator {
           timestamp: Date.now(),
           data
         });
-        await handleTurnComplete(this, sessionId, taskCtx, data);
+        const existingCoalesce = this.turnCompleteCoalesceTimers.get(sessionId);
+        if (existingCoalesce)
+          clearTimeout(existingCoalesce);
+        const coalescedData = data;
+        const coalesceTimer = setTimeout(() => {
+          this.turnCompleteCoalesceTimers.delete(sessionId);
+          const currentTask = this.tasks.get(sessionId);
+          if (currentTask && currentTask.status === "active") {
+            handleTurnComplete(this, sessionId, currentTask, coalescedData).catch((err) => {
+              this.log(`Coalesced turn-complete failed: ${err}`);
+            });
+          }
+        }, TURN_COMPLETE_COALESCE_MS);
+        this.turnCompleteCoalesceTimers.set(sessionId, coalesceTimer);
         break;
       }
       case "error": {
@@ -4169,10 +4393,10 @@ class PTYService {
     const hookUrl = `http://localhost:${this.runtime.getSetting("SERVER_PORT") ?? "2138"}/api/coding-agents/hooks`;
     if (resolvedAgentType === "claude") {
       try {
-        const settingsPath = join2(workdir, ".claude", "settings.json");
+        const settingsPath = join3(workdir, ".claude", "settings.json");
         let settings = {};
         try {
-          settings = JSON.parse(await readFile2(settingsPath, "utf-8"));
+          settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
         } catch {}
         const permissions = settings.permissions ?? {};
         permissions.allowedDirectories = [workdir];
@@ -4187,8 +4411,8 @@ class PTYService {
           settings.hooks = { ...existingHooks, ...hookProtocol.settingsHooks };
           this.log(`Injecting HTTP hooks for session ${sessionId}`);
         }
-        await mkdir(dirname(settingsPath), { recursive: true });
-        await writeFile2(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        await mkdir2(dirname2(settingsPath), { recursive: true });
+        await writeFile3(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
         this.log(`Wrote allowedDirectories [${workdir}] to ${settingsPath}`);
       } catch (err) {
         this.log(`Failed to write Claude settings: ${err}`);
@@ -4196,10 +4420,10 @@ class PTYService {
     }
     if (resolvedAgentType === "gemini") {
       try {
-        const settingsPath = join2(workdir, ".gemini", "settings.json");
+        const settingsPath = join3(workdir, ".gemini", "settings.json");
         let settings = {};
         try {
-          settings = JSON.parse(await readFile2(settingsPath, "utf-8"));
+          settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
         } catch {}
         const adapter = this.getAdapter("gemini");
         const hookProtocol = adapter.getHookTelemetryProtocol({
@@ -4211,8 +4435,8 @@ class PTYService {
           settings.hooks = { ...existingHooks, ...hookProtocol.settingsHooks };
           this.log(`Injecting Gemini CLI hooks for session ${sessionId}`);
         }
-        await mkdir(dirname(settingsPath), { recursive: true });
-        await writeFile2(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        await mkdir2(dirname2(settingsPath), { recursive: true });
+        await writeFile3(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
       } catch (err) {
         this.log(`Failed to write Gemini settings: ${err}`);
       }
@@ -4504,7 +4728,7 @@ class PTYService {
   static GITIGNORE_MARKER = "# orchestrator-injected (do not commit agent config/memory files)";
   static gitignoreLocks = new Map;
   async ensureOrchestratorGitignore(workdir) {
-    const gitignorePath = join2(workdir, ".gitignore");
+    const gitignorePath = join3(workdir, ".gitignore");
     const existing_lock = PTYService.gitignoreLocks.get(gitignorePath);
     if (existing_lock)
       await existing_lock;
@@ -4521,7 +4745,7 @@ class PTYService {
   async doEnsureGitignore(gitignorePath, workdir) {
     let existing = "";
     try {
-      existing = await readFile2(gitignorePath, "utf-8");
+      existing = await readFile3(gitignorePath, "utf-8");
     } catch {}
     if (existing.includes(PTYService.GITIGNORE_MARKER))
       return;
@@ -4536,14 +4760,14 @@ class PTYService {
     ];
     try {
       if (existing.length === 0) {
-        await writeFile2(gitignorePath, entries.join(`
+        await writeFile3(gitignorePath, entries.join(`
 `) + `
 `, "utf-8");
       } else {
         const separator = existing.endsWith(`
 `) ? "" : `
 `;
-        await appendFile(gitignorePath, separator + entries.join(`
+        await appendFile2(gitignorePath, separator + entries.join(`
 `) + `
 `, "utf-8");
       }
@@ -4687,13 +4911,13 @@ var spawnAgentAction = {
       }
       return { success: false, error: "NO_WORKSPACE" };
     }
-    const resolvedWorkdir = path2.resolve(workdir);
-    const workspaceBaseDir = path2.join(os.homedir(), ".milady", "workspaces");
+    const resolvedWorkdir = path3.resolve(workdir);
+    const workspaceBaseDir = path3.join(os2.homedir(), ".milady", "workspaces");
     const allowedPrefixes = [
-      path2.resolve(workspaceBaseDir),
-      path2.resolve(process.cwd())
+      path3.resolve(workspaceBaseDir),
+      path3.resolve(process.cwd())
     ];
-    const isAllowed = allowedPrefixes.some((prefix) => resolvedWorkdir.startsWith(prefix + path2.sep) || resolvedWorkdir === prefix);
+    const isAllowed = allowedPrefixes.some((prefix) => resolvedWorkdir.startsWith(prefix + path3.sep) || resolvedWorkdir === prefix);
     if (!isAllowed) {
       if (callback) {
         await callback({
@@ -5045,17 +5269,17 @@ function formatAge(timestamp) {
 
 // src/actions/coding-task-helpers.ts
 import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as os2 from "node:os";
-import * as path3 from "node:path";
+import * as fs2 from "node:fs";
+import * as os3 from "node:os";
+import * as path4 from "node:path";
 import {
   logger as logger5
 } from "@elizaos/core";
 function createScratchDir() {
-  const baseDir = path3.join(os2.homedir(), ".milady", "workspaces");
+  const baseDir = path4.join(os3.homedir(), ".milady", "workspaces");
   const scratchId = randomUUID();
-  const scratchDir = path3.join(baseDir, scratchId);
-  fs.mkdirSync(scratchDir, { recursive: true });
+  const scratchDir = path4.join(baseDir, scratchId);
+  fs2.mkdirSync(scratchDir, { recursive: true });
   return scratchDir;
 }
 function generateLabel(repo, task) {
@@ -5466,13 +5690,23 @@ var startCodingTaskAction = {
         repo = urlMatch[0];
       }
     }
-    if (!repo) {
+    const reuseRepo = params?.reuseRepo ?? content.reuseRepo ?? /\b(same\s+repo|same\s+project|continue|that\s+repo|the\s+repo|this\s+repo|in\s+the\s+repo)\b/i.test(content.text ?? "");
+    if (!repo && reuseRepo) {
       const coordinator = getCoordinator(runtime);
-      const lastRepo = coordinator?.getLastUsedRepo();
+      const lastRepo = await coordinator?.getLastUsedRepoAsync();
       if (lastRepo) {
         repo = lastRepo;
       }
     }
+    if (!repo && reuseRepo) {
+      const wsService2 = runtime.getService("CODING_WORKSPACE_SERVICE");
+      if (wsService2 && typeof wsService2.listWorkspaces === "function") {
+        const withRepo = wsService2.listWorkspaces().find((ws) => ws.repo);
+        if (withRepo) {
+          repo = withRepo.repo;
+        }
+      }
+    }
     const customCredentialKeys = runtime.getSetting("CUSTOM_CREDENTIAL_KEYS");
     let customCredentials;
     if (customCredentialKeys) {
@@ -5512,7 +5746,8 @@ var startCodingTaskAction = {
       return handleMultiAgent(ctx, agentsParam);
     }
     const task = params?.task ?? content.task;
-    const singleAgentSpec = task || "";
+    const userText = content.text?.trim() || "";
+    const singleAgentSpec = task || userText;
     return handleMultiAgent(ctx, singleAgentSpec);
   },
   parameters: [
@@ -6026,9 +6261,9 @@ 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 * as os4 from "node:os";
+import * as path6 from "node:path";
+import * as fs4 from "node:fs/promises";
 import {
   CredentialService,
   GitHubPatClient as GitHubPatClient2,
@@ -6241,17 +6476,17 @@ async function createPR(workspaceService, workspace, workspaceId, options, log)
 }
 
 // src/services/workspace-lifecycle.ts
-import * as fs2 from "node:fs";
-import * as path4 from "node:path";
+import * as fs3 from "node:fs";
+import * as path5 from "node:path";
 async function removeScratchDir(dirPath, baseDir, log) {
-  const resolved = path4.resolve(dirPath);
-  const resolvedBase = path4.resolve(baseDir) + path4.sep;
-  if (!resolved.startsWith(resolvedBase) && resolved !== path4.resolve(baseDir)) {
+  const resolved = path5.resolve(dirPath);
+  const resolvedBase = path5.resolve(baseDir) + path5.sep;
+  if (!resolved.startsWith(resolvedBase) && resolved !== path5.resolve(baseDir)) {
     console.warn(`[CodingWorkspaceService] Refusing to remove dir outside base: ${resolved}`);
     return;
   }
   try {
-    await fs2.promises.rm(resolved, { recursive: true, force: true });
+    await fs3.promises.rm(resolved, { recursive: true, force: true });
     log(`Removed scratch dir ${resolved}`);
   } catch (err) {
     console.warn(`[CodingWorkspaceService] Failed to remove scratch dir ${resolved}:`, err);
@@ -6264,7 +6499,7 @@ async function gcOrphanedWorkspaces(baseDir, workspaceTtlMs, trackedWorkspaceIds
   }
   let entries;
   try {
-    entries = await fs2.promises.readdir(baseDir, { withFileTypes: true });
+    entries = await fs3.promises.readdir(baseDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -6278,12 +6513,12 @@ async function gcOrphanedWorkspaces(baseDir, workspaceTtlMs, trackedWorkspaceIds
       skipped++;
       continue;
     }
-    const dirPath = path4.join(baseDir, entry.name);
+    const dirPath = path5.join(baseDir, entry.name);
     try {
-      const stat = await fs2.promises.stat(dirPath);
-      const age = now - stat.mtimeMs;
+      const stat2 = await fs3.promises.stat(dirPath);
+      const age = now - stat2.mtimeMs;
       if (age > workspaceTtlMs) {
-        await fs2.promises.rm(dirPath, { recursive: true, force: true });
+        await fs3.promises.rm(dirPath, { recursive: true, force: true });
         removed++;
       } else {
         skipped++;
@@ -6317,7 +6552,7 @@ class CodingWorkspaceService {
   constructor(runtime, config = {}) {
     this.runtime = runtime;
     this.serviceConfig = {
-      baseDir: config.baseDir ?? path5.join(os3.homedir(), ".milady", "workspaces"),
+      baseDir: config.baseDir ?? path6.join(os4.homedir(), ".milady", "workspaces"),
       branchPrefix: config.branchPrefix ?? "milady",
       debug: config.debug ?? false,
       workspaceTtlMs: config.workspaceTtlMs ?? 24 * 60 * 60 * 1000
@@ -6636,14 +6871,14 @@ class CodingWorkspaceService {
     const suggestedName = this.sanitizeWorkspaceName(name || record.label);
     const targetPath = await this.allocatePromotedPath(baseDir, suggestedName);
     try {
-      await fs3.rename(record.path, targetPath);
+      await fs4.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 });
+      await fs4.cp(record.path, targetPath, { recursive: true });
+      await fs4.access(targetPath);
+      await fs4.rm(record.path, { recursive: true, force: true });
     }
     const next = {
       ...record,
@@ -6716,15 +6951,15 @@ class CodingWorkspaceService {
     return compact || `scratch-${Date.now().toString(36)}`;
   }
   async allocatePromotedPath(baseDir, baseName) {
-    const baseResolved = path5.resolve(baseDir);
+    const baseResolved = path6.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}`)) {
+      const candidate = path6.resolve(baseResolved, candidateName);
+      if (candidate !== baseResolved && !candidate.startsWith(`${baseResolved}${path6.sep}`)) {
         continue;
       }
       try {
-        await fs3.access(candidate);
+        await fs4.access(candidate);
       } catch {
         return candidate;
       }
@@ -6733,10 +6968,10 @@ class CodingWorkspaceService {
   }
 }
 // src/api/agent-routes.ts
-import { access as access2, readFile as readFile3, realpath, rm as rm2 } from "node:fs/promises";
+import { access as access2, readFile as readFile4, 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 * as os5 from "node:os";
+import * as path7 from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
@@ -6748,23 +6983,23 @@ function shouldAutoPreflight() {
   return false;
 }
 function isPathInside(parent, candidate) {
-  return candidate === parent || candidate.startsWith(`${parent}${path6.sep}`);
+  return candidate === parent || candidate.startsWith(`${parent}${path7.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)) {
+  if (path7.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}`)) {
+  const normalized = path7.normalize(venvDir);
+  if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path7.sep}`)) {
     throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must stay within workdir");
   }
-  const workdirResolved = path6.resolve(workdir);
+  const workdirResolved = path7.resolve(workdir);
   const workdirReal = await realpath(workdirResolved);
-  const resolved = path6.resolve(workdirReal, normalized);
+  const resolved = path7.resolve(workdirReal, normalized);
   if (!isPathInside(workdirReal, resolved)) {
     throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV resolves outside workdir");
   }
@@ -6780,7 +7015,7 @@ async function resolveSafeVenvPath(workdir, venvDirRaw) {
     const maybeErr = err;
     if (maybeErr?.code !== "ENOENT")
       throw err;
-    const parentReal = await realpath(path6.dirname(resolved));
+    const parentReal = await realpath(path7.dirname(resolved));
     if (!isPathInside(workdirReal, parentReal)) {
       throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV parent resolves outside workdir");
     }
@@ -6796,10 +7031,10 @@ async function fileExists(filePath) {
   }
 }
 async function resolveRequirementsPath(workdir) {
-  const workdirReal = await realpath(path6.resolve(workdir));
+  const workdirReal = await realpath(path7.resolve(workdir));
   const candidates = [
-    path6.join(workdir, "apps", "api", "requirements.txt"),
-    path6.join(workdir, "requirements.txt")
+    path7.join(workdir, "apps", "api", "requirements.txt"),
+    path7.join(workdir, "requirements.txt")
   ];
   for (const candidate of candidates) {
     if (!await fileExists(candidate))
@@ -6813,7 +7048,7 @@ async function resolveRequirementsPath(workdir) {
   return null;
 }
 async function fingerprintRequirementsFile(requirementsPath) {
-  const file = await readFile3(requirementsPath);
+  const file = await readFile4(requirementsPath);
   return createHash("sha256").update(file).digest("hex");
 }
 async function runBenchmarkPreflight(workdir) {
@@ -6826,7 +7061,7 @@ async function runBenchmarkPreflight(workdir) {
   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 pythonInVenv = path7.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))
@@ -7034,21 +7269,21 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
         customCredentials,
         metadata
       } = body;
-      const workspaceBaseDir = path6.join(os4.homedir(), ".milady", "workspaces");
-      const workspaceBaseDirResolved = path6.resolve(workspaceBaseDir);
-      const cwdResolved = path6.resolve(process.cwd());
+      const workspaceBaseDir = path7.join(os5.homedir(), ".milady", "workspaces");
+      const workspaceBaseDirResolved = path7.resolve(workspaceBaseDir);
+      const cwdResolved = path7.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 resolved = path7.resolve(workdir);
         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));
+        const isAllowed = allowedPrefixes.some((prefix2) => resolvedReal === prefix2 || resolvedReal.startsWith(prefix2 + path7.sep));
         if (!isAllowed) {
           sendError(res, "workdir must be within workspace base directory or cwd", 403);
           return true;
@@ -7794,5 +8029,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=62DE82DAFB3D448A64756E2164756E21
+//# debugId=C832944FABDC8E0964756E2164756E21
 //# sourceMappingURL=index.js.map