@elizaos/plugin-agent-orchestrator 0.3.10 → 0.3.12

package/dist/index.js

@@ -98,15 +98,43 @@ var init_ansi_utils = __esm(() => {
   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;
 });
 
+// src/services/trajectory-context.ts
+function setTrajectoryContext(runtime, ctx) {
+  runtime[CTX_KEY] = ctx;
+}
+function clearTrajectoryContext(runtime) {
+  runtime[CTX_KEY] = undefined;
+}
+async function withTrajectoryContext(runtime, ctx, fn) {
+  setTrajectoryContext(runtime, ctx);
+  try {
+    return await fn();
+  } finally {
+    clearTrajectoryContext(runtime);
+  }
+}
+var CTX_KEY = "__orchestratorTrajectoryCtx";
+
 // src/services/swarm-coordinator-prompts.ts
 function buildSiblingSection(siblings) {
   if (!siblings || siblings.length === 0)
     return "";
+  const lines = siblings.map((s) => {
+    let line = `  - [${s.status}] "${s.label}" (${s.agentType}): ${s.originalTask}`;
+    if (s.completionSummary) {
+      line += `
+    Result: ${s.completionSummary}`;
+    } else if (s.lastKeyDecision) {
+      line += `
+    Latest: ${s.lastKeyDecision}`;
+    }
+    return line;
+  });
   return `
 Other agents in this swarm:
-` + siblings.map((s) => `  - [${s.status}] "${s.label}" (${s.agentType}): ${s.originalTask}`).join(`
+` + lines.join(`
 `) + `
-Use this context when the agent asks creative or architectural questions — ` + `your answer should be consistent with what sibling agents are working on.
+Use this context when the agent asks creative or architectural questions — ` + `your answer should be consistent with what sibling agents are doing.
 `;
 }
 function buildSharedDecisionsSection(decisions) {
@@ -168,6 +196,7 @@ ${recentOutput.slice(-3000)}
 ` + `- 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.
+` + `- Look for explicit "DECISION:" markers in the agent's output — these are the agent deliberately ` + `surfacing design choices. Always capture these as keyDecision.
 
 ` + `Respond with ONLY a JSON object:
 ` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}`;
@@ -209,6 +238,7 @@ ${recentOutput.slice(-3000)}
 ` + `- If the agent is clearly mid-operation (build output, test runner, git operations), use "ignore".
 ` + `- On check ${idleCheckNumber} of ${maxIdleChecks} — if unsure, lean toward "respond" with a nudge rather than "complete".
 ` + `- If the agent's output reveals a significant creative or architectural decision, ` + `include "keyDecision" with a brief one-line summary.
+` + `- Look for explicit "DECISION:" markers in the agent's output — always capture these as keyDecision.
 
 ` + `Respond with ONLY a JSON object:
 ` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}`;
@@ -258,6 +288,7 @@ ${turnOutput.slice(-3000)}
 ` + `- 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.
 
 ` + `Respond with ONLY a JSON object:
 ` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}`;
@@ -295,6 +326,7 @@ ${recentOutput.slice(-3000)}
 ` + `- 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.
+` + `Look for explicit "DECISION:" markers in the agent's output — always capture these as keyDecision.
 
 ` + `Include a JSON action block at the end of your response:
 ` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}
@@ -332,6 +364,7 @@ ${turnOutput.slice(-3000)}
 ` + `- 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.
 ` + `- 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.
 
 ` + `Include a JSON action block at the end of your response:
 ` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}
@@ -429,7 +462,7 @@ async function classifyEventTier(runtime, ctx, log) {
   }
   try {
     const prompt = buildTriagePrompt(ctx);
-    const result = await runtime.useModel(ModelType2.TEXT_SMALL, { prompt });
+    const result = await withTrajectoryContext(runtime, { source: "orchestrator", decisionType: "event-triage" }, () => runtime.useModel(ModelType2.TEXT_SMALL, { prompt }));
     const tier = parseTriageResponse(result);
     if (tier) {
       log(`Triage: LLM → ${tier}`);
@@ -504,7 +537,8 @@ __export(exports_swarm_decision_loop, {
   handleBlocked: () => handleBlocked,
   handleAutonomousDecision: () => handleAutonomousDecision,
   executeDecision: () => executeDecision,
-  checkAllTasksComplete: () => checkAllTasksComplete
+  checkAllTasksComplete: () => checkAllTasksComplete,
+  POST_SEND_COOLDOWN_MS: () => POST_SEND_COOLDOWN_MS
 });
 import * as path from "node:path";
 import { ModelType as ModelType3 } from "@elizaos/core";
@@ -544,11 +578,28 @@ function collectSiblings(ctx, currentSessionId) {
   for (const [sid, task] of ctx.tasks) {
     if (sid === currentSessionId)
       continue;
+    let lastKeyDecision;
+    for (let i = task.decisions.length - 1;i >= 0; i--) {
+      const d = task.decisions[i];
+      if (d.reasoning && d.decision !== "auto_resolved") {
+        lastKeyDecision = d.reasoning;
+        break;
+      }
+    }
+    for (let i = ctx.sharedDecisions.length - 1;i >= 0; i--) {
+      const sd = ctx.sharedDecisions[i];
+      if (sd.agentLabel === task.label) {
+        lastKeyDecision = sd.summary;
+        break;
+      }
+    }
     siblings.push({
       label: task.label,
       agentType: task.agentType,
       originalTask: task.originalTask,
-      status: task.status
+      status: task.status,
+      lastKeyDecision,
+      completionSummary: task.completionSummary
     });
   }
   return siblings;
@@ -601,6 +652,17 @@ async function drainPendingTurnComplete(ctx, sessionId) {
   ctx.log(`Draining buffered turn-complete for "${taskCtx.label}"`);
   await handleTurnComplete(ctx, sessionId, taskCtx, pendingData);
 }
+async function drainPendingBlocked(ctx, sessionId) {
+  if (!ctx.pendingBlocked.has(sessionId))
+    return;
+  const pendingData = ctx.pendingBlocked.get(sessionId);
+  ctx.pendingBlocked.delete(sessionId);
+  const taskCtx = ctx.tasks.get(sessionId);
+  if (!taskCtx || taskCtx.status !== "active")
+    return;
+  ctx.log(`Draining buffered blocked event for "${taskCtx.label}"`);
+  await handleBlocked(ctx, sessionId, taskCtx, pendingData);
+}
 function formatDecisionResponse(decision) {
   if (decision.action !== "respond")
     return;
@@ -706,9 +768,15 @@ async function fetchRecentOutput(ctx, sessionId, lines = 50) {
 async function makeCoordinationDecision(ctx, taskCtx, promptText, recentOutput) {
   const prompt = buildCoordinationPrompt(toContextSummary(taskCtx), promptText, recentOutput, toDecisionHistory(taskCtx), collectSiblings(ctx, taskCtx.sessionId), ctx.sharedDecisions, ctx.getSwarmContext());
   try {
-    const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
-      prompt
-    });
+    const result = await withTrajectoryContext(ctx.runtime, {
+      source: "orchestrator",
+      decisionType: "coordination",
+      sessionId: taskCtx.sessionId,
+      taskLabel: taskCtx.label,
+      repo: taskCtx.repo,
+      workdir: taskCtx.workdir,
+      originalTask: taskCtx.originalTask
+    }, () => ctx.runtime.useModel(ModelType3.TEXT_SMALL, { prompt }));
     return parseCoordinationResponse(result);
   } catch (err) {
     ctx.log(`LLM coordination call failed: ${err}`);
@@ -719,7 +787,8 @@ async function executeDecision(ctx, sessionId, decision) {
   if (!ctx.ptyService)
     return;
   switch (decision.action) {
-    case "respond":
+    case "respond": {
+      const taskCtx = ctx.tasks.get(sessionId);
       if (decision.useKeys && decision.keys) {
         await ctx.ptyService.sendKeysToSession(sessionId, decision.keys);
       } else if (decision.response !== undefined) {
@@ -729,7 +798,10 @@ async function executeDecision(ctx, sessionId, decision) {
           commitSharedDecisionIndex(ctx, sessionId, snapshotIndex);
         }
       }
+      if (taskCtx)
+        taskCtx.lastInputSentAt = Date.now();
       break;
+    }
     case "complete": {
       const taskCtx = ctx.tasks.get(sessionId);
       if (taskCtx) {
@@ -826,6 +898,18 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
     }
     return;
   }
+  const promptFingerprint = promptText.slice(0, 200);
+  if (ctx.inFlightDecisions.has(sessionId)) {
+    if (ctx.lastBlockedPromptFingerprint.get(sessionId) === promptFingerprint) {
+      ctx.log(`Skipping duplicate blocked event for ${taskCtx.label} (decision in-flight, same prompt)`);
+      return;
+    }
+    ctx.log(`New blocked prompt for ${taskCtx.label} while decision in-flight — buffering`);
+    ctx.pendingBlocked.set(sessionId, data);
+    ctx.lastBlockedPromptFingerprint.set(sessionId, promptFingerprint);
+    return;
+  }
+  ctx.lastBlockedPromptFingerprint.set(sessionId, promptFingerprint);
   ctx.broadcast({
     type: "blocked",
     sessionId,
@@ -879,6 +963,13 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
     ctx.pendingTurnComplete.set(sessionId, data);
     return;
   }
+  if (taskCtx.lastInputSentAt) {
+    const elapsed = Date.now() - taskCtx.lastInputSentAt;
+    if (elapsed < POST_SEND_COOLDOWN_MS) {
+      ctx.log(`Suppressing turn-complete for "${taskCtx.label}" — ` + `${Math.round(elapsed / 1000)}s since last input (cooldown ${POST_SEND_COOLDOWN_MS / 1000}s)`);
+      return;
+    }
+  }
   ctx.inFlightDecisions.add(sessionId);
   try {
     ctx.log(`Turn complete for "${taskCtx.label}" — assessing whether task is done`);
@@ -892,9 +983,15 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
     const decisionFromPipeline = false;
     const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx), collectSiblings(ctx, sessionId), ctx.sharedDecisions, ctx.getSwarmContext());
     try {
-      const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
-        prompt
-      });
+      const result = await withTrajectoryContext(ctx.runtime, {
+        source: "orchestrator",
+        decisionType: "turn-complete",
+        sessionId,
+        taskLabel: taskCtx.label,
+        repo: taskCtx.repo,
+        workdir: taskCtx.workdir,
+        originalTask: taskCtx.originalTask
+      }, () => ctx.runtime.useModel(ModelType3.TEXT_SMALL, { prompt }));
       decision = parseCoordinationResponse(result);
     } catch (err) {
       ctx.log(`Turn-complete LLM call failed: ${err}`);
@@ -938,6 +1035,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
     await drainPendingTurnComplete(ctx, sessionId);
+    await drainPendingBlocked(ctx, sessionId);
   }
 }
 async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, recentOutput, promptType) {
@@ -1041,6 +1139,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
     await drainPendingTurnComplete(ctx, sessionId);
+    await drainPendingBlocked(ctx, sessionId);
   }
 }
 async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recentOutput, promptType) {
@@ -1117,9 +1216,10 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
     await drainPendingTurnComplete(ctx, sessionId);
+    await drainPendingBlocked(ctx, sessionId);
   }
 }
-var DECISION_CB_TIMEOUT_MS = 30000, MAX_AUTO_RESPONSES = 10;
+var DECISION_CB_TIMEOUT_MS = 30000, MAX_AUTO_RESPONSES = 10, POST_SEND_COOLDOWN_MS = 15000;
 var init_swarm_decision_loop = __esm(() => {
   init_ansi_utils();
   init_swarm_event_triage();
@@ -2142,13 +2242,13 @@ var sendToAgentAction = {
 import * as os from "node:os";
 import * as path2 from "node:path";
 import {
-  logger as logger3
+  logger as logger4
 } from "@elizaos/core";
 
 // src/services/pty-service.ts
-import { mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+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,
@@ -2882,9 +2982,11 @@ async function classifyStallOutput(ctx) {
   }
   try {
     log(`Stall detected for ${sessionId}, asking LLM to classify...`);
-    const result = await runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt: systemPrompt
-    });
+    const result = await withTrajectoryContext(runtime, {
+      source: "orchestrator",
+      decisionType: "stall-classification",
+      sessionId
+    }, () => runtime.useModel(ModelType.TEXT_SMALL, { prompt: systemPrompt }));
     const jsonMatch = result.match(/\{[\s\S]*\}/);
     if (!jsonMatch) {
       log(`Stall classification: no JSON in LLM response`);
@@ -2996,9 +3098,15 @@ async function classifyAndDecideForCoordinator(ctx) {
   }
   try {
     log(`Stall detected for coordinator-managed ${sessionId}, combined classify+decide...`);
-    const result = await runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt: systemPrompt
-    });
+    const result = await withTrajectoryContext(runtime, {
+      source: "orchestrator",
+      decisionType: "stall-classify-decide",
+      sessionId,
+      taskLabel: taskContext.label,
+      repo: taskContext.repo,
+      workdir: taskContext.workdir,
+      originalTask: taskContext.originalTask
+    }, () => runtime.useModel(ModelType.TEXT_SMALL, { prompt: systemPrompt }));
     const jsonMatch = result.match(/\{[\s\S]*\}/);
     if (!jsonMatch) {
       log(`Combined classify+decide: no JSON in LLM response`);
@@ -3045,6 +3153,9 @@ async function classifyAndDecideForCoordinator(ctx) {
   }
 }
 
+// src/services/pty-service.ts
+init_swarm_decision_loop();
+
 // src/services/swarm-coordinator.ts
 init_ansi_utils();
 init_swarm_decision_loop();
@@ -3188,9 +3299,15 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
     const prompt = buildIdleCheckPrompt(contextSummary, recentOutput, idleMinutes, taskCtx.idleCheckCount, MAX_IDLE_CHECKS, decisionHistory, siblings, ctx.sharedDecisions, ctx.getSwarmContext());
     let decision = null;
     try {
-      const result = await ctx.runtime.useModel(ModelType4.TEXT_SMALL, {
-        prompt
-      });
+      const result = await withTrajectoryContext(ctx.runtime, {
+        source: "orchestrator",
+        decisionType: "idle-check",
+        sessionId,
+        taskLabel: taskCtx.label,
+        repo: taskCtx.repo,
+        workdir: taskCtx.workdir,
+        originalTask: taskCtx.originalTask
+      }, () => ctx.runtime.useModel(ModelType4.TEXT_SMALL, { prompt }));
       decision = parseCoordinationResponse(result);
     } catch (err) {
       ctx.log(`Idle check LLM call failed: ${err}`);
@@ -3249,6 +3366,8 @@ class SwarmCoordinator {
   pendingDecisions = new Map;
   inFlightDecisions = new Set;
   pendingTurnComplete = new Map;
+  lastBlockedPromptFingerprint = new Map;
+  pendingBlocked = new Map;
   chatCallback = null;
   wsBroadcast = null;
   agentDecisionCb = null;
@@ -3335,6 +3454,8 @@ class SwarmCoordinator {
     this.pendingDecisions.clear();
     this.inFlightDecisions.clear();
     this.pendingTurnComplete.clear();
+    this.lastBlockedPromptFingerprint.clear();
+    this.pendingBlocked.clear();
     this.unregisteredBuffer.clear();
     this.lastSeenOutput.clear();
     this.lastToolNotification.clear();
@@ -3716,6 +3837,65 @@ class SwarmCoordinator {
   }
 }
 
+// src/services/debug-capture.ts
+import { logger as logger2 } from "@elizaos/core";
+var captureManager = null;
+var initAttempted = false;
+function isDebugCaptureEnabled() {
+  return process.env.PARALLAX_DEBUG_CAPTURE === "1";
+}
+async function ensureCaptureManager() {
+  if (captureManager)
+    return captureManager;
+  if (initAttempted)
+    return null;
+  initAttempted = true;
+  if (!isDebugCaptureEnabled())
+    return null;
+  try {
+    const mod = await import("pty-state-capture");
+    const { PTYStateCaptureManager } = mod;
+    captureManager = new PTYStateCaptureManager({
+      outputRootDir: ".parallax/pty-captures",
+      defaultRows: 80,
+      defaultCols: 220
+    });
+    logger2.info("[debug-capture] PTY state capture enabled — writing to .parallax/pty-captures/");
+    return captureManager;
+  } catch {
+    logger2.debug("[debug-capture] pty-state-capture not available — capture disabled");
+    return null;
+  }
+}
+async function captureSessionOpen(sessionId, agentType) {
+  const mgr = await ensureCaptureManager();
+  if (!mgr)
+    return;
+  try {
+    await mgr.openSession(sessionId, { source: agentType });
+  } catch (err) {
+    logger2.debug(`[debug-capture] Failed to open session ${sessionId}: ${err}`);
+  }
+}
+async function captureFeed(sessionId, chunk, direction = "stdout") {
+  if (!captureManager)
+    return;
+  try {
+    await captureManager.feed(sessionId, chunk, direction);
+  } catch (err) {
+    logger2.debug(`[debug-capture] Feed error for ${sessionId}: ${err}`);
+  }
+}
+async function captureLifecycle(sessionId, event, detail) {
+  if (!captureManager)
+    return;
+  try {
+    await captureManager.lifecycle(sessionId, event, detail);
+  } catch (err) {
+    logger2.debug(`[debug-capture] Lifecycle error for ${sessionId}: ${err}`);
+  }
+}
+
 // src/services/pty-service.ts
 function getCoordinator(runtime) {
   const ptyService = runtime.getService("PTY_SERVICE");
@@ -3759,16 +3939,16 @@ class PTYService {
     const existing = servicesMap?.get?.("SWARM_COORDINATOR");
     if (existing && existing.length > 0) {
       service.coordinator = existing[0];
-      logger2.info("[PTYService] SwarmCoordinator already registered, skipping duplicate start");
+      logger3.info("[PTYService] SwarmCoordinator already registered, skipping duplicate start");
     } else {
       try {
         const coordinator = new SwarmCoordinator(runtime);
         coordinator.start(service);
         service.coordinator = coordinator;
         servicesMap?.set?.("SWARM_COORDINATOR", [coordinator]);
-        logger2.info("[PTYService] SwarmCoordinator wired and started");
+        logger3.info("[PTYService] SwarmCoordinator wired and started");
       } catch (err) {
-        logger2.error(`[PTYService] Failed to wire SwarmCoordinator: ${err}`);
+        logger3.error(`[PTYService] Failed to wire SwarmCoordinator: ${err}`);
       }
     }
     return service;
@@ -3950,6 +4130,9 @@ class PTYService {
         this.log(`Failed to write Gemini settings: ${err}`);
       }
     }
+    if (resolvedAgentType !== "shell" && workdir !== process.cwd()) {
+      await this.ensureOrchestratorGitignore(workdir);
+    }
     const spawnConfig = buildSpawnConfig(sessionId, {
       ...options,
       agentType: resolvedAgentType,
@@ -3989,6 +4172,21 @@ class PTYService {
     if (this.usingBunWorker) {
       setupOutputBuffer(ctx, session.id);
     }
+    if (isDebugCaptureEnabled()) {
+      captureSessionOpen(session.id, resolvedAgentType).catch(() => {});
+      if (this.usingBunWorker) {
+        this.manager.onSessionData(session.id, (data) => {
+          captureFeed(session.id, data, "stdout");
+        });
+      } else {
+        const ptySession = this.manager.getSession(session.id);
+        if (ptySession) {
+          ptySession.on("output", (data) => {
+            captureFeed(session.id, data, "stdout");
+          });
+        }
+      }
+    }
     if (resolvedInitialTask) {
       setupDeferredTaskDelivery(ctx, session, resolvedInitialTask, resolvedAgentType);
     }
@@ -4016,6 +4214,7 @@ class PTYService {
   async sendToSession(sessionId, input) {
     if (!this.manager)
       throw new Error("PTYService not initialized");
+    captureFeed(sessionId, input, "stdin");
     return sendToSession(this.ioContext(), sessionId, input);
   }
   async sendKeysToSession(sessionId, keys) {
@@ -4026,6 +4225,7 @@ class PTYService {
   async stopSession(sessionId, force = false) {
     if (!this.manager)
       throw new Error("PTYService not initialized");
+    captureLifecycle(sessionId, "session_stopped", force ? "force" : undefined);
     return stopSession(this.ioContext(), sessionId, this.sessionMetadata, this.sessionWorkdirs, (msg) => this.log(msg), force);
   }
   get defaultApprovalPreset() {
@@ -4101,12 +4301,12 @@ class PTYService {
   handleHookEvent(sessionId, event, data) {
     const summary = event === "tool_running" ? `tool=${data.toolName ?? "?"}` : event === "permission_approved" ? `tool=${data.tool ?? "?"}` : JSON.stringify(data);
     if (event === "tool_running" || event === "permission_approved") {
-      logger2.debug(`[PTYService] Hook event for ${sessionId}: ${event} ${summary}`);
+      logger3.debug(`[PTYService] Hook event for ${sessionId}: ${event} ${summary}`);
     } else {
       this.log(`Hook event for ${sessionId}: ${event} ${summary}`);
     }
     if (this.manager && this.usingBunWorker) {
-      this.manager.notifyHookEvent(sessionId, event).catch((err) => logger2.debug(`[PTYService] Failed to forward hook event to session: ${err}`));
+      this.manager.notifyHookEvent(sessionId, event).catch((err) => logger3.debug(`[PTYService] Failed to forward hook event to session: ${err}`));
     }
     switch (event) {
       case "tool_running":
@@ -4140,6 +4340,13 @@ class PTYService {
     if (meta?.coordinatorManaged && this.coordinator?.getSupervisionLevel() === "autonomous") {
       const taskCtx = this.coordinator.getTaskContext(sessionId);
       if (taskCtx) {
+        if (taskCtx.lastInputSentAt) {
+          const elapsed = Date.now() - taskCtx.lastInputSentAt;
+          if (elapsed < POST_SEND_COOLDOWN_MS) {
+            this.log(`Suppressing stall classification for ${sessionId} — ` + `${Math.round(elapsed / 1000)}s since coordinator sent input`);
+            return null;
+          }
+        }
         return classifyAndDecideForCoordinator({
           sessionId,
           recentOutput,
@@ -4207,6 +4414,56 @@ class PTYService {
   async writeMemoryFile(agentType, workspacePath, content, options) {
     return this.getAdapter(agentType).writeMemoryFile(workspacePath, content, options);
   }
+  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 existing_lock = PTYService.gitignoreLocks.get(gitignorePath);
+    if (existing_lock)
+      await existing_lock;
+    const task = this.doEnsureGitignore(gitignorePath, workdir);
+    PTYService.gitignoreLocks.set(gitignorePath, task);
+    try {
+      await task;
+    } finally {
+      if (PTYService.gitignoreLocks.get(gitignorePath) === task) {
+        PTYService.gitignoreLocks.delete(gitignorePath);
+      }
+    }
+  }
+  async doEnsureGitignore(gitignorePath, workdir) {
+    let existing = "";
+    try {
+      existing = await readFile2(gitignorePath, "utf-8");
+    } catch {}
+    if (existing.includes(PTYService.GITIGNORE_MARKER))
+      return;
+    const entries = [
+      "",
+      PTYService.GITIGNORE_MARKER,
+      "CLAUDE.md",
+      ".claude/",
+      "GEMINI.md",
+      ".gemini/",
+      ".aider*"
+    ];
+    try {
+      if (existing.length === 0) {
+        await writeFile2(gitignorePath, entries.join(`
+`) + `
+`, "utf-8");
+      } else {
+        const separator = existing.endsWith(`
+`) ? "" : `
+`;
+        await appendFile(gitignorePath, separator + entries.join(`
+`) + `
+`, "utf-8");
+      }
+    } catch (err) {
+      this.log(`Failed to update .gitignore in ${workdir}: ${err}`);
+    }
+  }
   onSessionEvent(callback) {
     this.eventCallbacks.push(callback);
     return () => {
@@ -4254,7 +4511,7 @@ class PTYService {
     return this.metricsTracker.getAll();
   }
   log(message) {
-    logger2.debug(`[PTYService] ${message}`);
+    logger3.debug(`[PTYService] ${message}`);
   }
 }
 
@@ -4300,7 +4557,7 @@ var spawnAgentAction = {
   validate: async (runtime, _message) => {
     const ptyService = runtime.getService("PTY_SERVICE");
     if (!ptyService) {
-      logger3.warn("[SPAWN_CODING_AGENT] PTYService not available");
+      logger4.warn("[SPAWN_CODING_AGENT] PTYService not available");
       return false;
     }
     return true;
@@ -4413,7 +4670,7 @@ var spawnAgentAction = {
       ptyService.onSessionEvent((sessionId, event, data) => {
         if (sessionId !== session.id)
           return;
-        logger3.debug(`[Session ${sessionId}] ${event}: ${JSON.stringify(data)}`);
+        logger4.debug(`[Session ${sessionId}] ${event}: ${JSON.stringify(data)}`);
         if (!coordinator) {
           if (event === "blocked" && callback) {
             callback({
@@ -4465,7 +4722,7 @@ var spawnAgentAction = {
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger3.error("[SPAWN_CODING_AGENT] Failed to spawn agent:", errorMessage);
+      logger4.error("[SPAWN_CODING_AGENT] Failed to spawn agent:", errorMessage);
       if (callback) {
         await callback({
           text: `Failed to spawn coding agent: ${errorMessage}`
@@ -4513,9 +4770,170 @@ 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
+var QUERY_TIMEOUT_MS = 5000;
+function withTimeout2(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`Trajectory query timed out after ${ms}ms`)), ms))
+  ]);
+}
+function getTrajectoryLogger(runtime) {
+  const runtimeAny = runtime;
+  if (typeof runtimeAny.getService === "function") {
+    const svc = runtimeAny.getService("trajectory_logger");
+    if (svc && typeof svc === "object" && hasListMethod(svc)) {
+      return svc;
+    }
+  }
+  if (typeof runtimeAny.getServicesByType === "function") {
+    const services = runtimeAny.getServicesByType("trajectory_logger");
+    if (Array.isArray(services)) {
+      for (const svc of services) {
+        if (svc && typeof svc === "object" && hasListMethod(svc)) {
+          return svc;
+        }
+      }
+    }
+  }
+  return null;
+}
+function hasListMethod(obj) {
+  const candidate = obj;
+  return typeof candidate.listTrajectories === "function" && typeof candidate.getTrajectoryDetail === "function";
+}
+function extractInsights(response, purpose) {
+  const insights = [];
+  const decisionPattern = /DECISION:\s*(.+?)(?:\n|$)/gi;
+  let match;
+  while ((match = decisionPattern.exec(response)) !== null) {
+    insights.push(match[1].trim());
+  }
+  const keyDecisionPattern = /"keyDecision"\s*:\s*"([^"]+)"/g;
+  while ((match = keyDecisionPattern.exec(response)) !== null) {
+    insights.push(match[1].trim());
+  }
+  if ((purpose === "turn-complete" || purpose === "coordination") && insights.length === 0) {
+    const reasoningPattern = /"reasoning"\s*:\s*"([^"]{20,200})"/;
+    const reasoningMatch = response.match(reasoningPattern);
+    if (reasoningMatch) {
+      insights.push(reasoningMatch[1].trim());
+    }
+  }
+  return insights;
+}
+function isRelevant(experience, taskDescription) {
+  if (!taskDescription)
+    return true;
+  const taskWords = new Set(taskDescription.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 3));
+  const insightWords = experience.insight.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 3);
+  let overlap = 0;
+  for (const word of insightWords) {
+    if (taskWords.has(word))
+      overlap++;
+    if (overlap >= 2)
+      return true;
+  }
+  return false;
+}
+async function queryPastExperience(runtime, options = {}) {
+  const {
+    maxTrajectories = 30,
+    maxEntries = 8,
+    lookbackHours = 48,
+    taskDescription,
+    repo
+  } = options;
+  const logger5 = getTrajectoryLogger(runtime);
+  if (!logger5)
+    return [];
+  const startDate = new Date(Date.now() - lookbackHours * 60 * 60 * 1000).toISOString();
+  try {
+    const result = await withTimeout2(logger5.listTrajectories({
+      source: "orchestrator",
+      limit: maxTrajectories,
+      startDate
+    }), QUERY_TIMEOUT_MS);
+    if (!result.trajectories || result.trajectories.length === 0)
+      return [];
+    const experiences = [];
+    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 decisionType = metadata?.orchestrator?.decisionType ?? "unknown";
+      const taskLabel = metadata?.orchestrator?.taskLabel ?? "";
+      const trajectoryRepo = metadata?.orchestrator?.repo;
+      if (repo && (!trajectoryRepo || trajectoryRepo !== repo))
+        continue;
+      for (const step of detail.steps) {
+        if (!step.llmCalls)
+          continue;
+        for (const call of step.llmCalls) {
+          if (!call.response)
+            continue;
+          const insights = extractInsights(call.response, call.purpose ?? decisionType);
+          for (const insight of insights) {
+            experiences.push({
+              timestamp: call.timestamp ?? summary.startTime,
+              decisionType: call.purpose ?? decisionType,
+              taskLabel,
+              insight
+            });
+          }
+        }
+      }
+    }
+    let filtered = taskDescription ? experiences.filter((e) => isRelevant(e, taskDescription)) : experiences;
+    if (filtered.length === 0 && experiences.length > 0) {
+      filtered = experiences;
+    }
+    const seen = new Map;
+    for (const exp of filtered) {
+      const key = exp.insight.toLowerCase();
+      const existing = seen.get(key);
+      if (!existing || exp.timestamp > existing.timestamp) {
+        seen.set(key, exp);
+      }
+    }
+    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);
+    return [];
+  }
+}
+function formatPastExperience(experiences) {
+  if (experiences.length === 0)
+    return "";
+  const lines = experiences.map((e) => {
+    const age = formatAge(e.timestamp);
+    const label = e.taskLabel ? ` [${e.taskLabel}]` : "";
+    return `- ${e.insight}${label} (${age})`;
+  });
+  return `# Past Experience
+
+` + `The following decisions and insights were captured from recent agent sessions. ` + `Use them to avoid repeating mistakes and to stay consistent with established patterns.
+
+` + `${lines.join(`
+`)}
+`;
+}
+function formatAge(timestamp) {
+  const diffMs = Date.now() - timestamp;
+  const hours = Math.floor(diffMs / (1000 * 60 * 60));
+  if (hours < 1)
+    return "just now";
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
 
 // src/actions/coding-task-helpers.ts
 import { randomUUID } from "node:crypto";
@@ -4523,7 +4941,7 @@ import * as fs from "node:fs";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
 import {
-  logger as logger4
+  logger as logger5
 } from "@elizaos/core";
 function createScratchDir() {
   const baseDir = path3.join(os2.homedir(), ".milady", "workspaces");
@@ -4568,7 +4986,7 @@ ${preview}` : `Agent "${label}" completed the task.`
           });
         }
         ptyService.stopSession(sessionId, true).catch((err) => {
-          logger4.warn(`[START_CODING_TASK] Failed to stop session for "${label}" after task complete: ${err}`);
+          logger5.warn(`[START_CODING_TASK] Failed to stop session for "${label}" after task complete: ${err}`);
         });
       }
       if (event === "error" && callback) {
@@ -4581,7 +4999,7 @@ ${preview}` : `Agent "${label}" completed the task.`
       const wsService = runtime.getService("CODING_WORKSPACE_SERVICE");
       if (wsService) {
         wsService.removeScratchDir(scratchDir).catch((err) => {
-          logger4.warn(`[START_CODING_TASK] Failed to cleanup scratch dir for "${label}": ${err}`);
+          logger5.warn(`[START_CODING_TASK] Failed to cleanup scratch dir for "${label}": ${err}`);
         });
       }
     }
@@ -4617,6 +5035,26 @@ function stripAgentPrefix(spec) {
   }
   return spec;
 }
+function buildSwarmMemoryInstructions(agentLabel, agentTask, allSubtasks, agentIndex) {
+  const siblingTasks = allSubtasks.filter((_, i) => i !== agentIndex).map((t, i) => `  ${i + 1}. ${t}`).join(`
+`);
+  return `# Swarm Coordination
+
+` + `You are agent "${agentLabel}" in a multi-agent swarm of ${allSubtasks.length} agents.
+` + `Your task: ${agentTask}
+
+` + `Other agents are working on:
+${siblingTasks}
+
+` + `## Coordination Rules
+
+` + `- **Follow the Shared Context exactly.** The planning brief above contains ` + `concrete decisions (names, file paths, APIs, conventions). Use them as-is.
+` + `- **Surface design decisions.** If you need to make a creative or architectural ` + `choice not covered by the Shared Context (naming something, choosing a library, ` + `designing an interface, picking an approach), state your decision clearly in your ` + `output so the orchestrator can share it with sibling agents. Write it as:
+` + `  "DECISION: [brief description of what you decided and why]"
+` + `- **Don't contradict sibling work.** If the orchestrator tells you about decisions ` + `other agents have made, align with them.
+` + `- **Ask when uncertain.** If your task depends on another agent's output and you ` + `don't have enough context, ask rather than guessing.
+`;
+}
 async function generateSwarmContext(runtime, subtasks, userRequest) {
   const taskList = subtasks.map((t, i) => `  ${i + 1}. ${t}`).join(`
 `);
@@ -4627,25 +5065,28 @@ async function generateSwarmContext(runtime, subtasks, userRequest) {
 ` + `Subtasks being assigned:
 ${taskList}
 
-` + `Generate a concise shared context brief (3-8 bullet points) covering:
+` + `Generate a concise shared context brief (3-10 bullet points) covering:
 ` + `- Project intent and overall goal
 ` + `- Key constraints or preferences from the user's request
 ` + `- Conventions all agents should follow (naming, style, patterns, tone)
 ` + `- How subtasks relate to each other (dependencies, shared interfaces, etc.)
 ` + `- Any decisions that should be consistent across all agents
 
-` + `Only include what's relevant — skip categories that don't apply. ` + `Be specific and actionable, not generic. Keep it under 200 words.
+` + `CRITICAL — Concrete Decisions:
+` + `If any subtask involves creative choices (naming a feature, choosing an approach, ` + `designing an API, picking a concept), YOU must make those decisions NOW in this brief. ` + `Do NOT leave creative choices to individual agents — they run in parallel and will ` + `each make different choices, causing inconsistency.
+` + `For example: if one agent builds a feature and another writes tests for it, ` + `decide the feature name, file paths, function signatures, and key design choices here ` + `so both agents use the same names and structure.
+
+` + `Only include what's relevant — skip categories that don't apply. ` + `Be specific and actionable, not generic. Be as detailed as the task requires — ` + `a trivial task needs a few bullets, a complex task deserves a thorough roadmap.
 
 ` + `Output ONLY the bullet points, no preamble.`;
   try {
-    const result = await runtime.useModel(ModelType5.TEXT_SMALL, {
+    const result = await withTrajectoryContext(runtime, { source: "orchestrator", decisionType: "swarm-context-generation" }, () => runtime.useModel(ModelType5.TEXT_SMALL, {
       prompt,
-      maxTokens: 400,
       temperature: 0.3
-    });
+    }));
     return result?.trim() || "";
   } catch (err) {
-    logger5.warn(`Swarm context generation failed: ${err}`);
+    logger6.warn(`Swarm context generation failed: ${err}`);
     return "";
   }
 }
@@ -4703,6 +5144,13 @@ async function handleMultiAgent(ctx, agentsParam) {
     const coordinator = getCoordinator(runtime);
     coordinator?.setSwarmContext(swarmContext);
   }
+  const pastExperience = await queryPastExperience(runtime, {
+    taskDescription: userRequest,
+    lookbackHours: 48,
+    maxEntries: 8,
+    repo
+  });
+  const pastExperienceBlock = formatPastExperience(pastExperience);
   const results = [];
   for (const [i, spec] of agentSpecs.entries()) {
     let specAgentType = defaultAgentType;
@@ -4759,12 +5207,16 @@ ${swarmContext}
 --- End Shared Context ---` : specTask;
       const initialTask = specPiRequested ? toPiCommand(taskWithContext) : taskWithContext;
       const displayType = specPiRequested ? "pi" : specAgentType;
+      const swarmMemory = agentSpecs.length > 1 && swarmContext ? buildSwarmMemoryInstructions(specLabel, specTask, cleanSubtasks, i) : undefined;
+      const agentMemory = [memoryContent, swarmMemory, pastExperienceBlock].filter(Boolean).join(`
+
+`) || undefined;
       const session = await ptyService.spawnSession({
         name: `coding-${Date.now()}-${i}`,
         agentType: specAgentType,
         workdir,
         initialTask,
-        memoryContent,
+        memoryContent: agentMemory,
         credentials,
         approvalPreset: approvalPreset ?? ptyService.defaultApprovalPreset,
         customCredentials,
@@ -4806,7 +5258,7 @@ ${swarmContext}
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger5.error(`[START_CODING_TASK] Failed to spawn agent ${i + 1}:`, errorMessage);
+      logger6.error(`[START_CODING_TASK] Failed to spawn agent ${i + 1}:`, errorMessage);
       results.push({
         sessionId: "",
         agentType: specAgentType,
@@ -4838,7 +5290,7 @@ ${swarmContext}
   };
 }
 async function handleSingleAgent(ctx, task) {
-  logger5.debug(`[START_CODING_TASK] handleSingleAgent called, agentType=${ctx.defaultAgentType}, task=${task ? "yes" : "none"}, repo=${ctx.repo ?? "none"}`);
+  logger6.debug(`[START_CODING_TASK] handleSingleAgent called, agentType=${ctx.defaultAgentType}, task=${task ? "yes" : "none"}, repo=${ctx.repo ?? "none"}`);
   const {
     runtime,
     ptyService,
@@ -4898,14 +5350,14 @@ async function handleSingleAgent(ctx, task) {
   } else {
     workdir = createScratchDir();
   }
-  logger5.debug(`[START_CODING_TASK] Spawning ${agentType} agent, task: ${task ? `"${task.slice(0, 80)}..."` : "(none)"}, workdir: ${workdir}`);
+  logger6.debug(`[START_CODING_TASK] Spawning ${agentType} agent, task: ${task ? `"${task.slice(0, 80)}..."` : "(none)"}, workdir: ${workdir}`);
   try {
     if (agentType !== "shell" && agentType !== "pi") {
       const [preflight] = await ptyService.checkAvailableAgents([
         agentType
       ]);
       if (preflight && !preflight.installed) {
-        logger5.warn(`[START_CODING_TASK] ${preflight.adapter} CLI not installed`);
+        logger6.warn(`[START_CODING_TASK] ${preflight.adapter} CLI not installed`);
         if (callback) {
           await callback({
             text: `${preflight.adapter} CLI is not installed.
@@ -4915,19 +5367,29 @@ 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;
     const displayType = piRequested ? "pi" : agentType;
+    const pastExperience = await queryPastExperience(runtime, {
+      taskDescription: task,
+      lookbackHours: 48,
+      maxEntries: 6,
+      repo
+    });
+    const pastExperienceBlock = formatPastExperience(pastExperience);
+    const agentMemory = [memoryContent, pastExperienceBlock].filter(Boolean).join(`
+
+`) || 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,
       workdir,
       initialTask,
-      memoryContent,
+      memoryContent: agentMemory,
       credentials,
       approvalPreset: approvalPreset ?? ptyService.defaultApprovalPreset,
       customCredentials,
@@ -4940,7 +5402,7 @@ Docs: ${preflight.docsUrl}`
         label
       }
     });
-    logger5.debug(`[START_CODING_TASK] Session spawned: ${session.id} (${session.status})`);
+    logger6.debug(`[START_CODING_TASK] Session spawned: ${session.id} (${session.status})`);
     const isScratchWorkspace = !repo;
     const scratchDir = isScratchWorkspace ? workdir : null;
     registerSessionEvents(ptyService, runtime, session.id, label, scratchDir, callback, !!coordinator);
@@ -4981,7 +5443,7 @@ Session ID: ${session.id}` });
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    logger5.error("[START_CODING_TASK] Failed to spawn agent:", errorMessage);
+    logger6.error("[START_CODING_TASK] Failed to spawn agent:", errorMessage);
     if (callback) {
       await callback({
         text: `Failed to start coding agent: ${errorMessage}`
@@ -5162,7 +5624,7 @@ var startCodingTaskAction = {
 
 // src/actions/stop-agent.ts
 import {
-  logger as logger6
+  logger as logger7
 } from "@elizaos/core";
 var stopAgentAction = {
   name: "STOP_CODING_AGENT",
@@ -5241,7 +5703,7 @@ var stopAgentAction = {
         try {
           await ptyService.stopSession(session2.id);
         } catch (err) {
-          logger6.error(`Failed to stop session ${session2.id}: ${err}`);
+          logger7.error(`Failed to stop session ${session2.id}: ${err}`);
         }
       }
       if (state?.codingSession) {
@@ -7006,5 +7468,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=D706621831E2790E64756E2164756E21
+//# debugId=4383E51DF7A1F4A764756E2164756E21
 //# sourceMappingURL=index.js.map