@elizaos/plugin-agent-orchestrator 0.3.10 → 0.3.11

package/dist/actions/coding-task-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-task-handlers.d.ts","sourceRoot":"","sources":["../../src/actions/coding-task-handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,aAAa,EAElB,KAAK,MAAM,EAEX,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EACL,KAAK,eAAe,EAKrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AA0E7E,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC9C,WAAW,EAAE,gBAAgB,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACtD,QAAQ,EAAE,eAAe,GAAG,SAAS,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IACzB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,gBAAgB,EAAE,eAAe,CAAC;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,iBAAiB,EACtB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAoQnC;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAoMnC"}
+{"version":3,"file":"coding-task-handlers.d.ts","sourceRoot":"","sources":["../../src/actions/coding-task-handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,aAAa,EAElB,KAAK,MAAM,EAEX,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EACL,KAAK,eAAe,EAKrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAgI7E,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC9C,WAAW,EAAE,gBAAgB,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACtD,QAAQ,EAAE,eAAe,GAAG,SAAS,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IACzB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,gBAAgB,EAAE,eAAe,CAAC;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,iBAAiB,EACtB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAyRnC;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAgNnC"}

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}`);
@@ -544,11 +577,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 +651,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 +767,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}`);
@@ -826,6 +893,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,
@@ -892,9 +971,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 +1023,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 +1127,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,6 +1204,7 @@ 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;
@@ -2146,7 +2234,7 @@ import {
 } 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 {
@@ -2882,9 +2970,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 +3086,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`);
@@ -3188,9 +3284,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 +3351,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 +3439,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();
@@ -3950,6 +4056,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,
@@ -4207,6 +4316,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 () => {
@@ -4516,6 +4675,167 @@ import {
   logger as logger5,
   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 logger4 = getTrajectoryLogger(runtime);
+  if (!logger4)
+    return [];
+  const startDate = new Date(Date.now() - lookbackHours * 60 * 60 * 1000).toISOString();
+  try {
+    const result = await withTimeout2(logger4.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(logger4.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";
@@ -4617,6 +4937,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,22 +4967,25 @@ 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}`);
@@ -4703,6 +5046,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 +5109,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,
@@ -4920,6 +5274,16 @@ Docs: ${preflight.docsUrl}`
     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})`);
     const session = await ptyService.spawnSession({
@@ -4927,7 +5291,7 @@ Docs: ${preflight.docsUrl}`
       agentType,
       workdir,
       initialTask,
-      memoryContent,
+      memoryContent: agentMemory,
       credentials,
       approvalPreset: approvalPreset ?? ptyService.defaultApprovalPreset,
       customCredentials,
@@ -7006,5 +7370,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=D706621831E2790E64756E2164756E21
+//# debugId=1AF5CF89CDA1169464756E2164756E21
 //# sourceMappingURL=index.js.map