@elizaos/plugin-agent-orchestrator 0.3.9 → 0.3.10

package/dist/index.js

@@ -99,7 +99,35 @@ var init_ansi_utils = __esm(() => {
 });
 
 // src/services/swarm-coordinator-prompts.ts
-function buildCoordinationPrompt(taskCtx, promptText, recentOutput, decisionHistory) {
+function buildSiblingSection(siblings) {
+  if (!siblings || siblings.length === 0)
+    return "";
+  return `
+Other agents in this swarm:
+` + siblings.map((s) => `  - [${s.status}] "${s.label}" (${s.agentType}): ${s.originalTask}`).join(`
+`) + `
+Use this context when the agent asks creative or architectural questions — ` + `your answer should be consistent with what sibling agents are working on.
+`;
+}
+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 +138,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 +167,12 @@ ${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.
 
 ` + `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 +184,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 +208,12 @@ ${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.
 
 ` + `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 +224,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 +257,12 @@ ${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.
 
 ` + `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 +273,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 +294,13 @@ ${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.
+
 ` + `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 +311,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 +331,10 @@ ${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.
 
 ` + `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 +360,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;
@@ -502,6 +539,57 @@ function toDecisionHistory(taskCtx) {
     reasoning: d.reasoning
   }));
 }
+function collectSiblings(ctx, currentSessionId) {
+  const siblings = [];
+  for (const [sid, task] of ctx.tasks) {
+    if (sid === currentSessionId)
+      continue;
+    siblings.push({
+      label: task.label,
+      agentType: task.agentType,
+      originalTask: task.originalTask,
+      status: task.status
+    });
+  }
+  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;
@@ -542,8 +630,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 +653,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 +665,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,7 +704,7 @@ 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
@@ -599,7 +723,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 +746,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");
@@ -759,7 +890,7 @@ 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
@@ -784,6 +915,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,
@@ -834,7 +966,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 +1014,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",
@@ -934,7 +1067,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)
@@ -2388,7 +2521,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 +2531,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) {
@@ -3031,7 +3174,18 @@ 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, {
@@ -3098,11 +3252,15 @@ class SwarmCoordinator {
   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 +3274,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");
@@ -3167,6 +3339,9 @@ class SwarmCoordinator {
     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 +3385,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 +3408,8 @@ class SwarmCoordinator {
       registeredAt: Date.now(),
       lastActivityAt: Date.now(),
       idleCheckCount: 0,
-      taskDelivered: false
+      taskDelivered: false,
+      lastSeenDecisionIndex: 0
     });
     this.broadcast({
       type: "task_registered",
@@ -3378,7 +3564,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 +3899,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 +3910,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 +3927,29 @@ 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}`);
+      }
+    }
     const spawnConfig = buildSpawnConfig(sessionId, {
       ...options,
       agentType: resolvedAgentType,
@@ -3893,6 +4105,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 +4120,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;
     }
@@ -4295,7 +4513,8 @@ var spawnAgentAction = {
 
 // src/actions/coding-task-handlers.ts
 import {
-  logger as logger5
+  logger as logger5,
+  ModelType as ModelType5
 } from "@elizaos/core";
 
 // src/actions/coding-task-helpers.ts
@@ -4371,6 +4590,65 @@ ${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;
+}
+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-8 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.
+
+` + `Output ONLY the bullet points, no preamble.`;
+  try {
+    const result = await runtime.useModel(ModelType5.TEXT_SMALL, {
+      prompt,
+      maxTokens: 400,
+      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 +4696,13 @@ 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 results = [];
   for (const [i, spec] of agentSpecs.entries()) {
     let specAgentType = defaultAgentType;
@@ -4427,51 +4712,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,7 +4752,12 @@ 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 session = await ptyService.spawnSession({
         name: `coding-${Date.now()}-${i}`,
@@ -6319,6 +6572,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 +6589,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 +6613,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 +7006,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=54C728A058C6B9C264756E2164756E21
+//# debugId=D706621831E2790E64756E2164756E21
 //# sourceMappingURL=index.js.map