@elizaos/plugin-agent-orchestrator 0.3.9 → 0.3.11

package/dist/index.js

@@ -98,8 +98,64 @@ 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 buildCoordinationPrompt(taskCtx, promptText, recentOutput, decisionHistory) {
+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:
+` + lines.join(`
+`) + `
+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) {
+  if (!decisions || decisions.length === 0)
+    return "";
+  return `
+Key decisions made by other agents in this swarm:
+` + decisions.slice(-10).map((d) => `  - [${d.agentLabel}] ${d.summary}`).join(`
+`) + `
+Align with these decisions for consistency — don't contradict them unless the task requires it.
+`;
+}
+function buildSwarmContextSection(swarmContext) {
+  if (!swarmContext)
+    return "";
+  return `
+Project context (from planning phase):
+${swarmContext}
+`;
+}
+function buildCoordinationPrompt(taskCtx, promptText, recentOutput, decisionHistory, siblingTasks, sharedDecisions, swarmContext) {
   const historySection = decisionHistory.length > 0 ? `
 Previous decisions for this session:
 ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
@@ -110,7 +166,7 @@ ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.
 ` + `Original task: "${taskCtx.originalTask}"
 ` + `Working directory: ${taskCtx.workdir}
 ` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}
-` + historySection + `
+` + buildSwarmContextSection(swarmContext) + buildSiblingSection(siblingTasks) + buildSharedDecisionsSection(sharedDecisions) + historySection + `
 Recent terminal output (last 50 lines):
 ` + `---
 ${recentOutput.slice(-3000)}
@@ -139,11 +195,13 @@ ${recentOutput.slice(-3000)}
 ` + `- Only use "complete" if the agent confirmed it verified ALL test plan items after creating the PR.
 ` + `- 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": "..."}`;
+` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}`;
 }
-function buildIdleCheckPrompt(taskCtx, recentOutput, idleMinutes, idleCheckNumber, maxIdleChecks, decisionHistory) {
+function buildIdleCheckPrompt(taskCtx, recentOutput, idleMinutes, idleCheckNumber, maxIdleChecks, decisionHistory, siblingTasks, sharedDecisions, swarmContext) {
   const historySection = decisionHistory.length > 0 ? `
 Previous decisions for this session:
 ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
@@ -155,7 +213,7 @@ ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.
 ` + `Working directory: ${taskCtx.workdir}
 ` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}
 ` + `Idle check: ${idleCheckNumber} of ${maxIdleChecks} (session will be force-escalated after ${maxIdleChecks})
-` + historySection + `
+` + buildSwarmContextSection(swarmContext) + buildSiblingSection(siblingTasks) + buildSharedDecisionsSection(sharedDecisions) + historySection + `
 Recent terminal output (last 50 lines):
 ` + `---
 ${recentOutput.slice(-3000)}
@@ -179,11 +237,13 @@ ${recentOutput.slice(-3000)}
 ` + `- If the output shows an error or the agent seems stuck in a loop, escalate.
 ` + `- 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": "..."}`;
+` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}`;
 }
-function buildTurnCompletePrompt(taskCtx, turnOutput, decisionHistory) {
+function buildTurnCompletePrompt(taskCtx, turnOutput, decisionHistory, siblingTasks, sharedDecisions, swarmContext) {
   const historySection = decisionHistory.length > 0 ? `
 Previous decisions for this session:
 ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
@@ -194,7 +254,7 @@ ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.
 ` + `Original task: "${taskCtx.originalTask}"
 ` + `Working directory: ${taskCtx.workdir}
 ` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}
-` + historySection + `
+` + buildSwarmContextSection(swarmContext) + buildSiblingSection(siblingTasks) + buildSharedDecisionsSection(sharedDecisions) + historySection + `
 Output from this turn:
 ` + `---
 ${turnOutput.slice(-3000)}
@@ -227,11 +287,13 @@ ${turnOutput.slice(-3000)}
 ` + `- 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.
 
 ` + `Respond with ONLY a JSON object:
-` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
+` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}`;
 }
-function buildBlockedEventMessage(taskCtx, promptText, recentOutput, decisionHistory) {
+function buildBlockedEventMessage(taskCtx, promptText, recentOutput, decisionHistory, siblingTasks, sharedDecisions, swarmContext) {
   const historySection = decisionHistory.length > 0 ? `
 Previous decisions:
 ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
@@ -242,7 +304,7 @@ ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptT
 ` + `Task: "${taskCtx.originalTask}"
 ` + `Workdir: ${taskCtx.workdir}
 ` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}
-` + historySection + `
+` + buildSwarmContextSection(swarmContext) + buildSiblingSection(siblingTasks) + buildSharedDecisionsSection(sharedDecisions) + historySection + `
 Recent terminal output:
 ---
 ${recentOutput.slice(-3000)}
@@ -263,11 +325,14 @@ ${recentOutput.slice(-3000)}
 ` + `- If a PR was just created, respond to review & verify test plan items before completing.
 ` + `- 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": "..."}
+` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}
 ` + "```";
 }
-function buildTurnCompleteEventMessage(taskCtx, turnOutput, decisionHistory) {
+function buildTurnCompleteEventMessage(taskCtx, turnOutput, decisionHistory, siblingTasks, sharedDecisions, swarmContext) {
   const historySection = decisionHistory.length > 0 ? `
 Previous decisions:
 ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
@@ -278,7 +343,7 @@ ${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptT
 ` + `Task: "${taskCtx.originalTask}"
 ` + `Workdir: ${taskCtx.workdir}
 ` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}
-` + historySection + `
+` + buildSwarmContextSection(swarmContext) + buildSiblingSection(siblingTasks) + buildSharedDecisionsSection(sharedDecisions) + historySection + `
 Turn output:
 ---
 ${turnOutput.slice(-3000)}
@@ -298,9 +363,11 @@ ${turnOutput.slice(-3000)}
 ` + `- 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.
+` + `- 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": "..."}
+` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "...", "keyDecision": "..."}
 ` + "```";
 }
 function parseCoordinationResponse(llmOutput) {
@@ -326,6 +393,9 @@ function parseCoordinationResponse(llmOutput) {
         return null;
       }
     }
+    if (typeof parsed.keyDecision === "string" && parsed.keyDecision.trim()) {
+      result.keyDecision = parsed.keyDecision.trim().slice(0, 240);
+    }
     return result;
   } catch {
     return null;
@@ -392,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}`);
@@ -502,6 +572,74 @@ function toDecisionHistory(taskCtx) {
     reasoning: d.reasoning
   }));
 }
+function collectSiblings(ctx, currentSessionId) {
+  const siblings = [];
+  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,
+      lastKeyDecision,
+      completionSummary: task.completionSummary
+    });
+  }
+  return siblings;
+}
+function enrichWithSharedDecisions(ctx, sessionId, response) {
+  const taskCtx = ctx.tasks.get(sessionId);
+  if (!taskCtx)
+    return { response };
+  const allDecisions = ctx.sharedDecisions;
+  const lastSeen = taskCtx.lastSeenDecisionIndex;
+  const snapshotEnd = allDecisions.length;
+  if (lastSeen >= snapshotEnd)
+    return { response };
+  if (response.length < 20) {
+    return { response };
+  }
+  const unseen = allDecisions.slice(lastSeen, snapshotEnd);
+  const contextBlock = unseen.map((d) => `[${d.agentLabel}] ${d.summary}`).join("; ");
+  return {
+    response: `${response}
+
+(Context from other agents: ${contextBlock})`,
+    snapshotIndex: snapshotEnd
+  };
+}
+function commitSharedDecisionIndex(ctx, sessionId, snapshotIndex) {
+  const taskCtx = ctx.tasks.get(sessionId);
+  if (taskCtx) {
+    taskCtx.lastSeenDecisionIndex = snapshotIndex;
+  }
+}
+function recordKeyDecision(ctx, agentLabel, decision) {
+  if (!decision.keyDecision)
+    return;
+  ctx.sharedDecisions.push({
+    agentLabel,
+    summary: decision.keyDecision,
+    timestamp: Date.now()
+  });
+  ctx.log(`Shared decision from "${agentLabel}": ${decision.keyDecision}`);
+}
 async function drainPendingTurnComplete(ctx, sessionId) {
   if (!ctx.pendingTurnComplete.has(sessionId))
     return;
@@ -513,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;
@@ -542,8 +691,16 @@ function checkAllTasksComplete(ctx) {
     return;
   const terminalStates = new Set(["completed", "stopped", "error"]);
   const allDone = tasks.every((t) => terminalStates.has(t.status));
-  if (!allDone)
+  if (!allDone) {
+    const statuses = tasks.map((t) => `${t.label}=${t.status}`).join(", ");
+    ctx.log(`checkAllTasksComplete: not all done yet — ${statuses}`);
+    return;
+  }
+  if (ctx.swarmCompleteNotified) {
+    ctx.log("checkAllTasksComplete: already notified — skipping");
     return;
+  }
+  ctx.swarmCompleteNotified = true;
   const completed = tasks.filter((t) => t.status === "completed");
   const stopped = tasks.filter((t) => t.status === "stopped");
   const errored = tasks.filter((t) => t.status === "error");
@@ -557,7 +714,7 @@ function checkAllTasksComplete(ctx) {
   if (errored.length > 0) {
     parts.push(`${errored.length} errored`);
   }
-  ctx.sendChatMessage(`All ${tasks.length} coding agents finished (${parts.join(", ")}). Review their work when you're ready.`, "coding-agent");
+  ctx.log(`checkAllTasksComplete: all ${tasks.length} tasks terminal (${parts.join(", ")}) — firing swarm_complete`);
   ctx.broadcast({
     type: "swarm_complete",
     sessionId: "",
@@ -569,6 +726,34 @@ function checkAllTasksComplete(ctx) {
       errored: errored.length
     }
   });
+  const swarmCompleteCb = ctx.getSwarmCompleteCallback();
+  const sendFallbackSummary = () => {
+    ctx.sendChatMessage(`All ${tasks.length} coding agents finished (${parts.join(", ")}). Review their work when you're ready.`, "coding-agent");
+  };
+  if (swarmCompleteCb) {
+    ctx.log("checkAllTasksComplete: swarm complete callback is wired — calling synthesis");
+    const taskSummaries = tasks.map((t) => ({
+      sessionId: t.sessionId,
+      label: t.label,
+      agentType: t.agentType,
+      originalTask: t.originalTask,
+      status: t.status,
+      completionSummary: t.completionSummary ?? ""
+    }));
+    withTimeout(Promise.resolve().then(() => swarmCompleteCb({
+      tasks: taskSummaries,
+      total: tasks.length,
+      completed: completed.length,
+      stopped: stopped.length,
+      errored: errored.length
+    })), DECISION_CB_TIMEOUT_MS, "swarmCompleteCb").catch((err) => {
+      ctx.log(`Swarm complete callback failed: ${err} — falling back to generic summary`);
+      sendFallbackSummary();
+    });
+  } else {
+    ctx.log("checkAllTasksComplete: no synthesis callback — sending generic message");
+    sendFallbackSummary();
+  }
 }
 async function fetchRecentOutput(ctx, sessionId, lines = 50) {
   if (!ctx.ptyService)
@@ -580,11 +765,17 @@ async function fetchRecentOutput(ctx, sessionId, lines = 50) {
   }
 }
 async function makeCoordinationDecision(ctx, taskCtx, promptText, recentOutput) {
-  const prompt = buildCoordinationPrompt(toContextSummary(taskCtx), promptText, recentOutput, toDecisionHistory(taskCtx));
+  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}`);
@@ -599,7 +790,11 @@ async function executeDecision(ctx, sessionId, decision) {
       if (decision.useKeys && decision.keys) {
         await ctx.ptyService.sendKeysToSession(sessionId, decision.keys);
       } else if (decision.response !== undefined) {
-        await ctx.ptyService.sendToSession(sessionId, decision.response);
+        const { response: enriched, snapshotIndex } = enrichWithSharedDecisions(ctx, sessionId, decision.response);
+        await ctx.ptyService.sendToSession(sessionId, enriched);
+        if (snapshotIndex !== undefined) {
+          commitSharedDecisionIndex(ctx, sessionId, snapshotIndex);
+        }
       }
       break;
     case "complete": {
@@ -618,6 +813,9 @@ async function executeDecision(ctx, sessionId, decision) {
         const rawOutput = await ctx.ptyService.getSessionOutput(sessionId, 50);
         summary = extractCompletionSummary(rawOutput);
       } catch {}
+      if (taskCtx) {
+        taskCtx.completionSummary = summary || decision.reasoning || "";
+      }
       ctx.sendChatMessage(summary ? `Finished "${taskCtx?.label ?? sessionId}".
 
 ${summary}` : `Finished "${taskCtx?.label ?? sessionId}".`, "coding-agent");
@@ -695,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,
@@ -759,11 +969,17 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
     }
     let decision = null;
     const decisionFromPipeline = false;
-    const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
+    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}`);
@@ -784,6 +1000,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
       response: formatDecisionResponse(decision),
       reasoning: decision.reasoning
     });
+    recordKeyDecision(ctx, taskCtx.label, decision);
     ctx.broadcast({
       type: "turn_assessment",
       sessionId,
@@ -806,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) {
@@ -834,7 +1052,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
       decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
     } else {
       if (agentDecisionCb) {
-        const eventMessage = buildBlockedEventMessage(toContextSummary(taskCtx), promptText, output, toDecisionHistory(taskCtx));
+        const eventMessage = buildBlockedEventMessage(toContextSummary(taskCtx), promptText, output, toDecisionHistory(taskCtx), collectSiblings(ctx, sessionId), ctx.sharedDecisions, ctx.getSwarmContext());
         try {
           decision = await withTimeout(agentDecisionCb(eventMessage, sessionId, taskCtx), DECISION_CB_TIMEOUT_MS, "agentDecisionCb");
           if (decision)
@@ -882,6 +1100,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
       response: formatDecisionResponse(decision),
       reasoning: decision.reasoning
     });
+    recordKeyDecision(ctx, taskCtx.label, decision);
     taskCtx.autoResolvedCount = 0;
     ctx.broadcast({
       type: "coordination_decision",
@@ -908,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) {
@@ -934,7 +1154,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
       decision = await makeCoordinationDecision(ctx, taskCtx, promptText, output);
     } else {
       if (agentDecisionCb) {
-        const eventMessage = buildBlockedEventMessage(toContextSummary(taskCtx), promptText, output, toDecisionHistory(taskCtx));
+        const eventMessage = buildBlockedEventMessage(toContextSummary(taskCtx), promptText, output, toDecisionHistory(taskCtx), collectSiblings(ctx, sessionId), ctx.sharedDecisions, ctx.getSwarmContext());
         try {
           decision = await withTimeout(agentDecisionCb(eventMessage, sessionId, taskCtx), DECISION_CB_TIMEOUT_MS, "agentDecisionCb");
           if (decision)
@@ -984,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;
@@ -2013,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 {
@@ -2388,7 +2609,7 @@ async function stopSession(ctx, sessionId, sessionMetadata, sessionWorkdirs, log
     const workdir = sessionWorkdirs.get(sessionId);
     if (workdir) {
       try {
-        await cleanupClaudeHooks(workdir, log);
+        await cleanupAgentHooks(workdir, log);
       } catch {}
     }
     sessionMetadata.delete(sessionId);
@@ -2398,17 +2619,27 @@ async function stopSession(ctx, sessionId, sessionMetadata, sessionWorkdirs, log
     log(`Stopped session ${sessionId}`);
   }
 }
-async function cleanupClaudeHooks(workdir, log) {
-  const settingsPath = join(workdir, ".claude", "settings.json");
-  try {
-    const raw = await readFile(settingsPath, "utf-8");
-    const settings = JSON.parse(raw);
-    if (!settings.hooks)
-      return;
-    delete settings.hooks;
-    await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-    log(`Cleaned up hooks from ${settingsPath}`);
-  } catch {}
+async function cleanupAgentHooks(workdir, log) {
+  const settingsPaths = [
+    join(workdir, ".claude", "settings.json"),
+    join(workdir, ".gemini", "settings.json")
+  ];
+  for (const settingsPath of settingsPaths) {
+    try {
+      const raw = await readFile(settingsPath, "utf-8");
+      const settings = JSON.parse(raw);
+      if (!settings.hooks)
+        continue;
+      delete settings.hooks;
+      await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+      log(`Cleaned up hooks from ${settingsPath}`);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        log(`Failed to clean up hooks from ${settingsPath}: ${err}`);
+      }
+    }
+  }
 }
 function subscribeToOutput(ctx, sessionId, callback) {
   if (ctx.usingBunWorker) {
@@ -2739,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`);
@@ -2853,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`);
@@ -3031,12 +3270,29 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
       response: d.response,
       reasoning: d.reasoning
     }));
-    const prompt = buildIdleCheckPrompt(contextSummary, recentOutput, idleMinutes, taskCtx.idleCheckCount, MAX_IDLE_CHECKS, decisionHistory);
+    const siblings = [];
+    for (const [sid, task] of ctx.tasks) {
+      if (sid === sessionId)
+        continue;
+      siblings.push({
+        label: task.label,
+        agentType: task.agentType,
+        originalTask: task.originalTask,
+        status: task.status
+      });
+    }
+    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}`);
@@ -3095,14 +3351,20 @@ class SwarmCoordinator {
   pendingDecisions = new Map;
   inFlightDecisions = new Set;
   pendingTurnComplete = new Map;
+  lastBlockedPromptFingerprint = new Map;
+  pendingBlocked = new Map;
   chatCallback = null;
   wsBroadcast = null;
   agentDecisionCb = null;
+  swarmCompleteCb = null;
   unregisteredBuffer = new Map;
   idleWatchdogTimer = null;
   lastSeenOutput = new Map;
   lastToolNotification = new Map;
   _paused = false;
+  sharedDecisions = [];
+  _swarmContext = "";
+  swarmCompleteNotified = false;
   pauseBuffer = [];
   pauseTimeout = null;
   constructor(runtime) {
@@ -3116,6 +3378,20 @@ class SwarmCoordinator {
     this.wsBroadcast = cb;
     this.log("WS broadcast callback wired");
   }
+  setSwarmCompleteCallback(cb) {
+    this.swarmCompleteCb = cb;
+    this.log("Swarm complete callback wired");
+  }
+  getSwarmCompleteCallback() {
+    return this.swarmCompleteCb;
+  }
+  setSwarmContext(context) {
+    this._swarmContext = context;
+    this.log(`Swarm context set (${context.length} chars)`);
+  }
+  getSwarmContext() {
+    return this._swarmContext;
+  }
   setAgentDecisionCallback(cb) {
     this.agentDecisionCb = cb;
     this.log("Agent decision callback wired — events will route through Milaidy");
@@ -3163,10 +3439,15 @@ 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();
     this.agentDecisionCb = null;
+    this.sharedDecisions.length = 0;
+    this._swarmContext = "";
+    this.swarmCompleteNotified = false;
     this._paused = false;
     if (this.pauseTimeout) {
       clearTimeout(this.pauseTimeout);
@@ -3210,6 +3491,16 @@ class SwarmCoordinator {
     }
   }
   registerTask(sessionId, context) {
+    const allPreviousTerminal = this.tasks.size === 0 || Array.from(this.tasks.values()).every((t) => t.status === "completed" || t.status === "stopped" || t.status === "error");
+    if (allPreviousTerminal) {
+      this.swarmCompleteNotified = false;
+      if (this.tasks.size > 0) {
+        this.tasks.clear();
+        this.sharedDecisions.length = 0;
+        this._swarmContext = "";
+        this.log("Cleared stale swarm state for new swarm");
+      }
+    }
     this.tasks.set(sessionId, {
       sessionId,
       agentType: context.agentType,
@@ -3223,7 +3514,8 @@ class SwarmCoordinator {
       registeredAt: Date.now(),
       lastActivityAt: Date.now(),
       idleCheckCount: 0,
-      taskDelivered: false
+      taskDelivered: false,
+      lastSeenDecisionIndex: 0
     });
     this.broadcast({
       type: "task_registered",
@@ -3378,7 +3670,9 @@ class SwarmCoordinator {
         break;
       }
       case "stopped":
-        taskCtx.status = "stopped";
+        if (taskCtx.status !== "completed" && taskCtx.status !== "error") {
+          taskCtx.status = "stopped";
+        }
         this.inFlightDecisions.delete(sessionId);
         this.broadcast({
           type: "stopped",
@@ -3711,6 +4005,7 @@ class PTYService {
         this.log(`Failed to write approval config: ${err}`);
       }
     }
+    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");
@@ -3721,14 +4016,14 @@ class PTYService {
         const permissions = settings.permissions ?? {};
         permissions.allowedDirectories = [workdir];
         settings.permissions = permissions;
-        const serverPort = this.runtime.getSetting("SERVER_PORT") ?? "2138";
         const adapter = this.getAdapter("claude");
         const hookProtocol = adapter.getHookTelemetryProtocol({
-          httpUrl: `http://localhost:${serverPort}/api/coding-agents/hooks`,
+          httpUrl: hookUrl,
           sessionId
         });
         if (hookProtocol) {
-          settings.hooks = hookProtocol.settingsHooks;
+          const existingHooks = settings.hooks ?? {};
+          settings.hooks = { ...existingHooks, ...hookProtocol.settingsHooks };
           this.log(`Injecting HTTP hooks for session ${sessionId}`);
         }
         await mkdir(dirname(settingsPath), { recursive: true });
@@ -3738,6 +4033,32 @@ class PTYService {
         this.log(`Failed to write Claude settings: ${err}`);
       }
     }
+    if (resolvedAgentType === "gemini") {
+      try {
+        const settingsPath = join2(workdir, ".gemini", "settings.json");
+        let settings = {};
+        try {
+          settings = JSON.parse(await readFile2(settingsPath, "utf-8"));
+        } catch {}
+        const adapter = this.getAdapter("gemini");
+        const hookProtocol = adapter.getHookTelemetryProtocol({
+          httpUrl: hookUrl,
+          sessionId
+        });
+        if (hookProtocol) {
+          const existingHooks = settings.hooks ?? {};
+          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");
+      } catch (err) {
+        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,
@@ -3893,6 +4214,9 @@ class PTYService {
     } 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}`));
+    }
     switch (event) {
       case "tool_running":
         this.emitEvent(sessionId, "tool_running", data);
@@ -3905,6 +4229,9 @@ class PTYService {
       case "notification":
         this.emitEvent(sessionId, "message", data);
         break;
+      case "session_end":
+        this.emitEvent(sessionId, "stopped", { ...data, reason: "session_end" });
+        break;
       default:
         break;
     }
@@ -3989,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 () => {
@@ -4295,8 +4672,170 @@ var spawnAgentAction = {
 
 // src/actions/coding-task-handlers.ts
 import {
-  logger as logger5
+  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";
@@ -4371,6 +4910,88 @@ ${preview}` : `Agent "${label}" completed the task.`
 
 // src/actions/coding-task-handlers.ts
 var MAX_CONCURRENT_AGENTS = 8;
+var KNOWN_AGENT_PREFIXES = [
+  "claude",
+  "claude-code",
+  "claudecode",
+  "codex",
+  "openai",
+  "gemini",
+  "google",
+  "aider",
+  "pi",
+  "pi-ai",
+  "piai",
+  "pi-coding-agent",
+  "picodingagent",
+  "shell",
+  "bash"
+];
+function stripAgentPrefix(spec) {
+  const colonIdx = spec.indexOf(":");
+  if (colonIdx <= 0 || colonIdx >= 20)
+    return spec;
+  const prefix = spec.slice(0, colonIdx).trim().toLowerCase();
+  if (KNOWN_AGENT_PREFIXES.includes(prefix)) {
+    return spec.slice(colonIdx + 1).trim();
+  }
+  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(`
+`);
+  const prompt = `You are an AI orchestrator about to launch ${subtasks.length} parallel agents. ` + `Before they start, produce a brief shared context document so all agents stay aligned.
+
+` + `User's request: "${userRequest}"
+
+` + `Subtasks being assigned:
+${taskList}
+
+` + `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
+
+` + `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 withTrajectoryContext(runtime, { source: "orchestrator", decisionType: "swarm-context-generation" }, () => runtime.useModel(ModelType5.TEXT_SMALL, {
+      prompt,
+      temperature: 0.3
+    }));
+    return result?.trim() || "";
+  } catch (err) {
+    logger5.warn(`Swarm context generation failed: ${err}`);
+    return "";
+  }
+}
 async function handleMultiAgent(ctx, agentsParam) {
   const {
     runtime,
@@ -4418,6 +5039,20 @@ async function handleMultiAgent(ctx, agentsParam) {
       text: `Launching ${agentSpecs.length} agents${repo ? ` on ${repo}` : ""}...`
     });
   }
+  const cleanSubtasks = agentSpecs.map(stripAgentPrefix);
+  const userRequest = message.content?.text ?? agentsParam;
+  const swarmContext = agentSpecs.length > 1 ? await generateSwarmContext(runtime, cleanSubtasks, userRequest) : "";
+  if (swarmContext) {
+    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;
@@ -4427,51 +5062,14 @@ async function handleMultiAgent(ctx, agentsParam) {
     const colonIdx = spec.indexOf(":");
     if (ctx.agentSelectionStrategy !== "fixed" && colonIdx > 0 && colonIdx < 20) {
       const prefix = spec.slice(0, colonIdx).trim().toLowerCase();
-      const knownTypes = [
-        "claude",
-        "claude-code",
-        "claudecode",
-        "codex",
-        "openai",
-        "gemini",
-        "google",
-        "aider",
-        "pi",
-        "pi-ai",
-        "piai",
-        "pi-coding-agent",
-        "picodingagent",
-        "shell",
-        "bash"
-      ];
-      if (knownTypes.includes(prefix)) {
+      if (KNOWN_AGENT_PREFIXES.includes(prefix)) {
         specRequestedType = prefix;
         specPiRequested = isPiAgentType(prefix);
         specAgentType = normalizeAgentType(prefix);
         specTask = spec.slice(colonIdx + 1).trim();
       }
     } else if (ctx.agentSelectionStrategy === "fixed" && colonIdx > 0 && colonIdx < 20) {
-      const prefix = spec.slice(0, colonIdx).trim().toLowerCase();
-      const knownTypes = [
-        "claude",
-        "claude-code",
-        "claudecode",
-        "codex",
-        "openai",
-        "gemini",
-        "google",
-        "aider",
-        "pi",
-        "pi-ai",
-        "piai",
-        "pi-coding-agent",
-        "picodingagent",
-        "shell",
-        "bash"
-      ];
-      if (knownTypes.includes(prefix)) {
-        specTask = spec.slice(colonIdx + 1).trim();
-      }
+      specTask = stripAgentPrefix(spec);
     }
     const specLabel = explicitLabel ? `${explicitLabel}-${i + 1}` : generateLabel(repo, specTask);
     try {
@@ -4504,14 +5102,23 @@ async function handleMultiAgent(ctx, agentsParam) {
         }
       }
       const coordinator = getCoordinator(runtime);
-      const initialTask = specPiRequested ? toPiCommand(specTask) : specTask;
+      const taskWithContext = swarmContext ? `${specTask}
+
+--- Shared Context (from project planning) ---
+${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,
@@ -4667,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({
@@ -4674,7 +5291,7 @@ Docs: ${preflight.docsUrl}`
       agentType,
       workdir,
       initialTask,
-      memoryContent,
+      memoryContent: agentMemory,
       credentials,
       approvalPreset: approvalPreset ?? ptyService.defaultApprovalPreset,
       customCredentials,
@@ -6319,6 +6936,8 @@ async function handleHookRoutes(req, res, pathname, ctx) {
     sendError(res, "Missing hook_event_name", 400);
     return true;
   }
+  const toolName = payload.tool_name ?? payload.toolName;
+  const notificationType = payload.notification_type ?? payload.notificationType;
   const headerSessionId = req.headers["x-parallax-session-id"];
   const sessionId = headerSessionId ? headerSessionId : payload.cwd ? ctx.ptyService.findSessionIdByCwd(payload.cwd) : undefined;
   if (!sessionId) {
@@ -6334,13 +6953,13 @@ async function handleHookRoutes(req, res, pathname, ctx) {
         }
       });
       ctx.ptyService.handleHookEvent(sessionId, "permission_approved", {
-        tool: payload.tool_name
+        tool: toolName
       });
       return true;
     }
     case "PreToolUse": {
       ctx.ptyService.handleHookEvent(sessionId, "tool_running", {
-        toolName: payload.tool_name,
+        toolName,
         source: "hook"
       });
       sendJson(res, {
@@ -6358,19 +6977,56 @@ async function handleHookRoutes(req, res, pathname, ctx) {
       sendJson(res, {});
       return true;
     }
-    case "Notification": {
-      ctx.ptyService.handleHookEvent(sessionId, "notification", {
-        type: payload.notification_type,
-        message: payload.message
+    case "TaskCompleted": {
+      ctx.ptyService.handleHookEvent(sessionId, "task_complete", {
+        source: "hook_task_completed"
       });
       sendJson(res, {});
       return true;
     }
-    case "TaskCompleted": {
+    case "BeforeTool": {
+      ctx.ptyService.handleHookEvent(sessionId, "tool_running", {
+        toolName,
+        source: "gemini_hook"
+      });
+      sendJson(res, { decision: "allow", continue: true });
+      return true;
+    }
+    case "AfterTool": {
+      ctx.ptyService.handleHookEvent(sessionId, "notification", {
+        type: "tool_complete",
+        message: `Tool ${toolName ?? "unknown"} finished`
+      });
+      sendJson(res, { continue: true });
+      return true;
+    }
+    case "AfterAgent": {
       ctx.ptyService.handleHookEvent(sessionId, "task_complete", {
-        source: "hook_task_completed"
+        source: "gemini_hook"
       });
-      sendJson(res, {});
+      sendJson(res, { continue: true });
+      return true;
+    }
+    case "SessionEnd": {
+      ctx.ptyService.handleHookEvent(sessionId, "session_end", {
+        source: "hook"
+      });
+      sendJson(res, { continue: true });
+      return true;
+    }
+    case "Notification": {
+      if (notificationType === "ToolPermission") {
+        ctx.ptyService.handleHookEvent(sessionId, "permission_approved", {
+          tool: toolName
+        });
+        sendJson(res, { decision: "allow", continue: true });
+        return true;
+      }
+      ctx.ptyService.handleHookEvent(sessionId, "notification", {
+        type: notificationType,
+        message: payload.message
+      });
+      sendJson(res, { continue: true });
       return true;
     }
     default: {
@@ -6714,5 +7370,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=54C728A058C6B9C264756E2164756E21
+//# debugId=1AF5CF89CDA1169464756E2164756E21
 //# sourceMappingURL=index.js.map