@elizaos/plugin-agent-orchestrator 0.3.8 → 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;
@@ -471,6 +508,18 @@ __export(exports_swarm_decision_loop, {
 });
 import * as path from "node:path";
 import { ModelType as ModelType3 } from "@elizaos/core";
+function withTimeout(promise, ms, label) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    promise.then((val) => {
+      clearTimeout(timer);
+      resolve2(val);
+    }, (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
 function toContextSummary(taskCtx) {
   return {
     sessionId: taskCtx.sessionId,
@@ -490,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;
@@ -530,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");
@@ -545,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: "",
@@ -557,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)
@@ -568,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
@@ -587,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": {
@@ -606,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");
@@ -679,7 +822,7 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
     const count = taskCtx.autoResolvedCount;
     if (count <= 2 || count % 5 === 0) {
       const excerpt = promptText.length > 120 ? `${promptText.slice(0, 120)}...` : promptText;
-      ctx.sendChatMessage(`[${taskCtx.label}] Approved: ${excerpt}`, "coding-agent");
+      ctx.log(`[${taskCtx.label}] Approved: ${excerpt}`);
     }
     return;
   }
@@ -745,48 +888,16 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
       const raw = await fetchRecentOutput(ctx, sessionId);
       turnOutput = cleanForChat(raw);
     }
-    const agentDecisionCb = ctx.getAgentDecisionCallback();
     let decision = null;
-    let decisionFromPipeline = false;
-    const triageCtx = {
-      eventType: "turn_complete",
-      promptText: "",
-      recentOutput: turnOutput,
-      originalTask: taskCtx.originalTask
-    };
-    const tier = agentDecisionCb ? await classifyEventTier(ctx.runtime, triageCtx, ctx.log) : "routine";
-    if (tier === "routine") {
-      const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
-      try {
-        const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
-          prompt
-        });
-        decision = parseCoordinationResponse(result);
-      } catch (err) {
-        ctx.log(`Turn-complete LLM call failed: ${err}`);
-      }
-    } else {
-      if (agentDecisionCb) {
-        const eventMessage = buildTurnCompleteEventMessage(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
-        try {
-          decision = await agentDecisionCb(eventMessage, sessionId, taskCtx);
-          if (decision)
-            decisionFromPipeline = true;
-        } catch (err) {
-          ctx.log(`Agent decision callback failed for turn-complete: ${err} — falling back to small LLM`);
-        }
-      }
-      if (!decision) {
-        const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx));
-        try {
-          const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
-            prompt
-          });
-          decision = parseCoordinationResponse(result);
-        } catch (err) {
-          ctx.log(`Turn-complete LLM fallback call failed: ${err}`);
-        }
-      }
+    const decisionFromPipeline = false;
+    const prompt = buildTurnCompletePrompt(toContextSummary(taskCtx), turnOutput, toDecisionHistory(taskCtx), collectSiblings(ctx, sessionId), ctx.sharedDecisions, ctx.getSwarmContext());
+    try {
+      const result = await ctx.runtime.useModel(ModelType3.TEXT_SMALL, {
+        prompt
+      });
+      decision = parseCoordinationResponse(result);
+    } catch (err) {
+      ctx.log(`Turn-complete LLM call failed: ${err}`);
     }
     if (!decision) {
       ctx.log(`Turn-complete for "${taskCtx.label}": all decision paths failed — escalating`);
@@ -804,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,
@@ -817,7 +929,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
       if (decision.action === "respond") {
         const instruction = decision.response ?? "";
         const preview = instruction.length > 120 ? `${instruction.slice(0, 120)}...` : instruction;
-        ctx.sendChatMessage(`[${taskCtx.label}] Turn done, continuing: ${preview}`, "coding-agent");
+        ctx.log(`[${taskCtx.label}] Turn done, continuing: ${preview}`);
       } else if (decision.action === "escalate") {
         ctx.sendChatMessage(`[${taskCtx.label}] Turn finished — needs your attention: ${decision.reasoning}`, "coding-agent");
       }
@@ -854,9 +966,9 @@ 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 agentDecisionCb(eventMessage, sessionId, taskCtx);
+          decision = await withTimeout(agentDecisionCb(eventMessage, sessionId, taskCtx), DECISION_CB_TIMEOUT_MS, "agentDecisionCb");
           if (decision)
             decisionFromPipeline = true;
         } catch (err) {
@@ -902,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",
@@ -919,7 +1032,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
       if (decision.action === "respond") {
         const actionDesc = decision.useKeys ? `Sent keys: ${decision.keys?.join(", ")}` : decision.response ? `Responded: ${decision.response.length > 100 ? `${decision.response.slice(0, 100)}...` : decision.response}` : "Responded";
         const reasonExcerpt = decision.reasoning.length > 150 ? `${decision.reasoning.slice(0, 150)}...` : decision.reasoning;
-        ctx.sendChatMessage(`[${taskCtx.label}] ${actionDesc} — ${reasonExcerpt}`, "coding-agent");
+        ctx.log(`[${taskCtx.label}] ${actionDesc} — ${reasonExcerpt}`);
       } else if (decision.action === "escalate") {
         ctx.sendChatMessage(`[${taskCtx.label}] Needs your attention: ${decision.reasoning}`, "coding-agent");
       }
@@ -954,9 +1067,9 @@ 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 agentDecisionCb(eventMessage, sessionId, taskCtx);
+          decision = await withTimeout(agentDecisionCb(eventMessage, sessionId, taskCtx), DECISION_CB_TIMEOUT_MS, "agentDecisionCb");
           if (decision)
             decisionFromPipeline = true;
         } catch (err) {
@@ -1006,7 +1119,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
     await drainPendingTurnComplete(ctx, sessionId);
   }
 }
-var MAX_AUTO_RESPONSES = 10;
+var DECISION_CB_TIMEOUT_MS = 30000, MAX_AUTO_RESPONSES = 10;
 var init_swarm_decision_loop = __esm(() => {
   init_ansi_utils();
   init_swarm_event_triage();
@@ -2033,8 +2146,8 @@ import {
 } from "@elizaos/core";
 
 // src/services/pty-service.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { 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 {
   checkAdapters,
@@ -2349,6 +2462,8 @@ async function initializePTYManager(ctx) {
 }
 
 // src/services/pty-session-io.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 async function sendToSession(ctx, sessionId, input) {
   const session = ctx.manager.get(sessionId);
   if (!session) {
@@ -2403,6 +2518,12 @@ async function stopSession(ctx, sessionId, sessionMetadata, sessionWorkdirs, log
       }
     } catch {}
     ctx.outputUnsubscribers.delete(sessionId);
+    const workdir = sessionWorkdirs.get(sessionId);
+    if (workdir) {
+      try {
+        await cleanupAgentHooks(workdir, log);
+      } catch {}
+    }
     sessionMetadata.delete(sessionId);
     sessionWorkdirs.delete(sessionId);
     ctx.sessionOutputBuffers.delete(sessionId);
@@ -2410,6 +2531,28 @@ async function stopSession(ctx, sessionId, sessionMetadata, sessionWorkdirs, log
     log(`Stopped session ${sessionId}`);
   }
 }
+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) {
     const unsubscribe2 = ctx.manager.onSessionData(sessionId, callback);
@@ -2521,7 +2664,7 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
     taskSent = true;
     if (readyTimeout)
       clearTimeout(readyTimeout);
-    ctx.markTaskDelivered?.(sid);
+    ctx.markTaskDelivered(sid);
     setTimeout(() => sendTaskWithRetry(0), settleMs);
     if (ctx.usingBunWorker) {
       ctx.manager.removeListener("session_ready", onReady);
@@ -2570,7 +2713,12 @@ function buildSpawnConfig(sessionId, options, workdir) {
     type: options.agentType,
     workdir,
     inheritProcessEnv: false,
-    env: { ...buildSanitizedBaseEnv(), ...options.env, ...modelEnv },
+    env: {
+      ...buildSanitizedBaseEnv(),
+      ...options.env,
+      ...modelEnv,
+      PARALLAX_SESSION_ID: sessionId
+    },
     ...options.skipAdapterAutoResponse ? { skipAdapterAutoResponse: true } : {},
     adapterConfig: {
       ...options.credentials,
@@ -3026,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, {
@@ -3062,7 +3221,7 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
     });
     if (decision.action === "complete") {} else if (decision.action === "respond") {
       const actionDesc = decision.useKeys ? `Sent keys: ${decision.keys?.join(", ")}` : `Nudged: ${decision.response ?? ""}`;
-      ctx.sendChatMessage(`[${taskCtx.label}] Idle for ${idleMinutes}m — ${actionDesc}`, "coding-agent");
+      ctx.log(`[${taskCtx.label}] Idle for ${idleMinutes}m — ${actionDesc}`);
     } else if (decision.action === "escalate") {
       ctx.sendChatMessage(`[${taskCtx.label}] Idle for ${idleMinutes}m — needs your attention: ${decision.reasoning}`, "coding-agent");
     } else if (decision.action === "ignore") {
@@ -3093,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) {
@@ -3111,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");
@@ -3162,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);
@@ -3205,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,
@@ -3218,7 +3408,8 @@ class SwarmCoordinator {
       registeredAt: Date.now(),
       lastActivityAt: Date.now(),
       idleCheckCount: 0,
-      taskDelivered: false
+      taskDelivered: false,
+      lastSeenDecisionIndex: 0
     });
     this.broadcast({
       type: "task_registered",
@@ -3373,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",
@@ -3401,6 +3594,9 @@ class SwarmCoordinator {
           data
         });
         const toolData = data;
+        if (toolData.source === "hook") {
+          break;
+        }
         const now = Date.now();
         const STARTUP_GRACE_MS = 1e4;
         if (now - taskCtx.registeredAt < STARTUP_GRACE_MS) {
@@ -3420,7 +3616,7 @@ class SwarmCoordinator {
               }
             } catch {}
           }
-          this.sendChatMessage(`[${taskCtx.label}] Running ${toolDesc}.${urlSuffix} The agent is working outside the terminal — I'll let it finish.`, "coding-agent");
+          this.log(`[${taskCtx.label}] Running ${toolDesc}.${urlSuffix} The agent is working outside the terminal.`);
         }
         break;
       }
@@ -3703,21 +3899,55 @@ 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 = join(workdir, ".claude", "settings.json");
+        const settingsPath = join2(workdir, ".claude", "settings.json");
         let settings = {};
         try {
-          settings = JSON.parse(await readFile(settingsPath, "utf-8"));
+          settings = JSON.parse(await readFile2(settingsPath, "utf-8"));
         } catch {}
         const permissions = settings.permissions ?? {};
         permissions.allowedDirectories = [workdir];
         settings.permissions = permissions;
+        const adapter = this.getAdapter("claude");
+        const hookProtocol = adapter.getHookTelemetryProtocol({
+          httpUrl: hookUrl,
+          sessionId
+        });
+        if (hookProtocol) {
+          const existingHooks = settings.hooks ?? {};
+          settings.hooks = { ...existingHooks, ...hookProtocol.settingsHooks };
+          this.log(`Injecting HTTP hooks for session ${sessionId}`);
+        }
         await mkdir(dirname(settingsPath), { recursive: true });
-        await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        await writeFile2(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
         this.log(`Wrote allowedDirectories [${workdir}] to ${settingsPath}`);
       } catch (err) {
-        this.log(`Failed to write allowedDirectories: ${err}`);
+        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, {
@@ -3861,6 +4091,42 @@ class PTYService {
     const session = this.getSession(sessionId);
     return session?.status === "authenticating";
   }
+  findSessionIdByCwd(cwd) {
+    for (const [sessionId, workdir] of this.sessionWorkdirs) {
+      if (workdir === cwd)
+        return sessionId;
+    }
+    return;
+  }
+  handleHookEvent(sessionId, event, data) {
+    const summary = event === "tool_running" ? `tool=${data.toolName ?? "?"}` : event === "permission_approved" ? `tool=${data.tool ?? "?"}` : JSON.stringify(data);
+    if (event === "tool_running" || event === "permission_approved") {
+      logger2.debug(`[PTYService] Hook event for ${sessionId}: ${event} ${summary}`);
+    } 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);
+        break;
+      case "task_complete":
+        this.emitEvent(sessionId, "task_complete", data);
+        break;
+      case "permission_approved":
+        break;
+      case "notification":
+        this.emitEvent(sessionId, "message", data);
+        break;
+      case "session_end":
+        this.emitEvent(sessionId, "stopped", { ...data, reason: "session_end" });
+        break;
+      default:
+        break;
+    }
+  }
   async checkAvailableAgents(types) {
     const agentTypes = types ?? ["claude", "gemini", "codex", "aider"];
     return checkAdapters(agentTypes);
@@ -3988,9 +4254,7 @@ class PTYService {
     return this.metricsTracker.getAll();
   }
   log(message) {
-    if (this.serviceConfig.debug) {
-      logger2.debug(`[PTYService] ${message}`);
-    }
+    logger2.debug(`[PTYService] ${message}`);
   }
 }
 
@@ -4249,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
@@ -4325,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,
@@ -4372,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;
@@ -4381,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 {
@@ -4458,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}`,
@@ -6247,6 +6546,132 @@ async function handleCoordinatorRoutes(req, res, pathname, ctx) {
   return false;
 }
 
+// src/api/hook-routes.ts
+async function handleHookRoutes(req, res, pathname, ctx) {
+  if (pathname !== "/api/coding-agents/hooks")
+    return false;
+  const method = req.method?.toUpperCase();
+  if (method !== "POST") {
+    sendError(res, "Method not allowed", 405);
+    return true;
+  }
+  if (!ctx.ptyService) {
+    sendError(res, "PTY Service not available", 503);
+    return true;
+  }
+  let body;
+  try {
+    body = await parseBody(req);
+  } catch (err) {
+    sendError(res, err instanceof Error ? err.message : "Failed to parse request body", 400);
+    return true;
+  }
+  const payload = body;
+  const eventName = payload.hook_event_name;
+  if (!eventName) {
+    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) {
+    sendJson(res, { status: "ignored", reason: "session_not_found" });
+    return true;
+  }
+  switch (eventName) {
+    case "PermissionRequest": {
+      sendJson(res, {
+        hookSpecificOutput: {
+          hookEventName: "PermissionRequest",
+          decision: { behavior: "allow" }
+        }
+      });
+      ctx.ptyService.handleHookEvent(sessionId, "permission_approved", {
+        tool: toolName
+      });
+      return true;
+    }
+    case "PreToolUse": {
+      ctx.ptyService.handleHookEvent(sessionId, "tool_running", {
+        toolName,
+        source: "hook"
+      });
+      sendJson(res, {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow"
+        }
+      });
+      return true;
+    }
+    case "Stop": {
+      ctx.ptyService.handleHookEvent(sessionId, "task_complete", {
+        source: "hook"
+      });
+      sendJson(res, {});
+      return true;
+    }
+    case "TaskCompleted": {
+      ctx.ptyService.handleHookEvent(sessionId, "task_complete", {
+        source: "hook_task_completed"
+      });
+      sendJson(res, {});
+      return true;
+    }
+    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: "gemini_hook"
+      });
+      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: {
+      sendJson(res, { status: "ignored", reason: "unknown_event" });
+      return true;
+    }
+  }
+}
+
 // src/api/issue-routes.ts
 async function handleIssueRoutes(req, res, pathname, ctx) {
   const method = req.method?.toUpperCase();
@@ -6509,6 +6934,9 @@ function sendError(res, message, status = 400) {
   sendJson(res, { error: message }, status);
 }
 async function handleCodingAgentRoutes(req, res, pathname, ctx) {
+  if (await handleHookRoutes(req, res, pathname, ctx)) {
+    return true;
+  }
   if (await handleCoordinatorRoutes(req, res, pathname, ctx)) {
     return true;
   }
@@ -6578,5 +7006,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=87DC30F17636D1DA64756E2164756E21
+//# debugId=D706621831E2790E64756E2164756E21
 //# sourceMappingURL=index.js.map