@markus-global/cli 0.2.3 → 0.3.0

package/dist/markus.mjs

@@ -6248,7 +6248,7 @@ var init_context_engine = __esm({
           }
         }
         parts.push("\n## Working Strategy");
-        parts.push("For multi-step tasks: (1) Plan first \u2014 outline approach, use `todo.md` for long tasks. (2) Update progress after each step. (3) Restate objectives before each action. (4) On errors, analyze before retrying \u2014 try a different approach. (5) Offload large tool output to files.");
+        parts.push("For multi-step tasks: (1) Plan first \u2014 outline approach, use `todo.md` for long tasks. (2) Update progress after each step. (3) Restate objectives before each action. (4) On errors, analyze before retrying \u2014 try a different approach. (5) Offload large tool output to files. (6) For heavy subtasks that need many tool calls or lots of file reading, delegate to `spawn_subagent` to keep your own context lean. Use `spawn_subagents` to run independent subtasks in parallel.");
         const scenario = opts.scenario ?? "chat";
         parts.push(this.buildScenarioSection(scenario));
         const now2 = /* @__PURE__ */ new Date();
@@ -6313,6 +6313,28 @@ Current date and time: ${localStr} (${tz}, UTC${sign}${absH}:${absM})`);
             lines.push("4. **Handle blockers**: If you cannot proceed, set status to `blocked` with a clear explanation.");
             lines.push("5. **Submit for review**: When ALL subtasks are complete, call `task_submit_review` with summary + deliverables (MANDATORY \u2014 the task does NOT complete without this).");
             lines.push("");
+            lines.push("**Delegating subtasks to subagents (`spawn_subagent` / `spawn_subagents`):**");
+            lines.push("");
+            lines.push("Subagents are lightweight child loops with independent context windows. They inherit your tools but do NOT pollute your conversation history. Use them strategically:");
+            lines.push("");
+            lines.push("*DELEGATE to a subagent when the subtask is:*");
+            lines.push("- **Deep exploration / analysis**: reading and cross-referencing many files (>5), codebase-wide searches, architecture analysis \u2014 a subagent keeps your own context clean");
+            lines.push("- **Independent code modifications**: editing files in separate modules that don't depend on each other \u2014 perfect for `spawn_subagents` (parallel)");
+            lines.push("- **Research & information gathering**: web searches, reading long documents, comparing alternatives \u2014 heavy context that you don't need to retain");
+            lines.push("- **Test generation**: writing tests for already-implemented code \u2014 self-contained work with clear inputs/outputs");
+            lines.push("- **Documentation / content generation**: producing docs, READMEs, changelogs from existing code \u2014 doesn't need your live reasoning context");
+            lines.push("- **Repetitive multi-file refactoring**: renaming, format migrations, pattern replacements across many files \u2014 especially in parallel");
+            lines.push("");
+            lines.push("*Do NOT delegate when:*");
+            lines.push("- The subtask is quick (\u22643 tool calls) \u2014 overhead of spawning a subagent is not worth it");
+            lines.push("- The next subtask depends on detailed intermediate reasoning from this one \u2014 keep it in your own context");
+            lines.push("- The subtask requires back-and-forth decisions that depend on your overall plan");
+            lines.push("");
+            lines.push("*Parallel execution pattern (`spawn_subagents`):*");
+            lines.push("When you have N independent subtasks, use `spawn_subagents` with an array of tasks to run them all concurrently. Example: implementing separate API endpoints, writing tests for different modules, analyzing different components.");
+            lines.push("");
+            lines.push("*Workflow:* `subtask_create` (track) \u2192 `spawn_subagent`/`spawn_subagents` (execute) \u2192 verify result \u2192 `subtask_complete` (mark done).");
+            lines.push("");
             lines.push("**Quality standards:**");
             lines.push("- Use all available tools to produce thorough, high-quality output");
             lines.push("- If a tool call fails, analyze the error and try a different approach \u2014 do NOT repeat the same failing action");
@@ -6356,9 +6378,18 @@ Current date and time: ${localStr} (${tz}, UTC${sign}${absH}:${absM})`);
         const lines = ["\n## Your Identity"];
         if (opts.identity) {
           const self = opts.identity.self;
+          const teamName = opts.identity.team?.name;
           lines.push(`- Name: ${self.name}`);
           lines.push(`- Role: ${opts.role.name} (${opts.role.description})`);
-          lines.push(`- Position: ${self.agentRole === "manager" ? "Organization Manager \u2014 you lead the AI team" : "Team Member"}`);
+          if (self.agentRole === "manager" && teamName) {
+            lines.push(`- Position: Team Manager of **${teamName}**`);
+          } else if (self.agentRole === "manager") {
+            lines.push(`- Position: Team Manager`);
+          } else if (teamName) {
+            lines.push(`- Position: Member of **${teamName}**`);
+          } else {
+            lines.push(`- Position: Team Member`);
+          }
           if (self.skills.length > 0) {
             lines.push(`- Active Skills: ${self.skills.join(", ")}`);
           }
@@ -6378,19 +6409,25 @@ Current date and time: ${localStr} (${tz}, UTC${sign}${absH}:${absM})`);
           if (opts.identity.manager && opts.identity.self.agentRole !== "manager") {
             lines.push(`
 ### Your Manager`);
-            lines.push(`- ${opts.identity.manager.name} (AI Organization Manager) \u2014 report progress and escalate issues to them`);
+            lines.push(`- ${opts.identity.manager.name} (Team Manager) \u2014 report progress and escalate issues to them`);
           }
           if (opts.identity.colleagues.length > 0) {
-            lines.push(`
-### Your Colleagues`);
+            lines.push(teamName ? `
+### Your Team \u2014 ${teamName}` : "\n### Your Team");
             for (const c of opts.identity.colleagues) {
               const statusTag = c.status ? ` [${c.status}]` : "";
-              lines.push(`- ${c.name} (${c.role}, ${c.type})${statusTag}${c.skills?.length ? ` \u2014 skills: ${c.skills.join(", ")}` : ""}`);
+              lines.push(`- ${c.name} (${c.role})${statusTag}${c.skills?.length ? ` \u2014 skills: ${c.skills.join(", ")}` : ""}`);
+            }
+          }
+          if (opts.identity.otherTeams && opts.identity.otherTeams.length > 0) {
+            lines.push("\n### Other Teams (for cross-team coordination)");
+            for (const t of opts.identity.otherTeams) {
+              lines.push(`- **${t.name}**: ${t.members.map((m) => `${m.name} (${m.role})`).join(", ")}`);
             }
           }
           if (opts.identity.humans.length > 0) {
             lines.push(`
-### Human Team Members`);
+### Human Users`);
             for (const h of opts.identity.humans) {
               const tag = h.role === "owner" ? " \u2605 Owner" : h.role === "admin" ? " Admin" : "";
               lines.push(`- ${h.name}${tag}`);
@@ -6399,11 +6436,11 @@ Current date and time: ${localStr} (${tz}, UTC${sign}${absH}:${absM})`);
           if (opts.identity.self.agentRole === "manager") {
             lines.push(`
 ### Manager Responsibilities`);
-            lines.push("As Organization Manager, you are responsible for:");
-            lines.push("1. **Routing** \u2014 When receiving vague messages, determine which team member should handle it");
-            lines.push("2. **Coordination** \u2014 Assign tasks to the right agents based on their skills");
-            lines.push("3. **Reporting** \u2014 Proactively report team progress to human stakeholders");
-            lines.push("4. **Training** \u2014 Help new agents understand their roles and the organization context");
+            lines.push(`You manage${teamName ? ` the **${teamName}** team` : " your team"}. Your scope is your own team members listed above.`);
+            lines.push("1. **Routing** \u2014 Determine which team member should handle incoming requests");
+            lines.push("2. **Coordination** \u2014 Assign tasks to team members based on their skills and availability");
+            lines.push("3. **Reporting** \u2014 Report your team's progress to human stakeholders");
+            lines.push("4. **Cross-team** \u2014 Coordinate with other team managers via `agent_send_message` when work crosses team boundaries");
             lines.push("5. **Escalation** \u2014 Escalate issues that require human decision to the Owner");
           }
         } else {
@@ -7366,7 +7403,9 @@ var init_tool_selector = __esm({
       "memory_save",
       "memory_search",
       "deliverable_search",
-      "deliverable_create"
+      "deliverable_create",
+      "spawn_subagent",
+      "spawn_subagents"
     ]);
     ToolSelector = class {
       groups;
@@ -40979,10 +41018,53 @@ var init_patch = __esm({
 // ../core/dist/tools/process-manager.js
 import { spawn as spawn2 } from "node:child_process";
 import { resolve as resolve8 } from "node:path";
+function onBackgroundCompletion(cb) {
+  completionListeners.push(cb);
+  return () => {
+    const idx = completionListeners.indexOf(cb);
+    if (idx >= 0)
+      completionListeners.splice(idx, 1);
+  };
+}
+function drainCompletedNotifications() {
+  const results = [];
+  for (const s of sessions.values()) {
+    if (s.exitCode !== null && !s.notified) {
+      s.notified = true;
+      results.push({
+        sessionId: s.id,
+        command: s.command.slice(0, 200),
+        exitCode: s.exitCode,
+        durationMs: Date.now() - s.startedAt,
+        stderrTail: s.stderr.slice(-10).join("\n"),
+        stdoutTail: s.stdout.slice(-10).join("\n")
+      });
+    }
+  }
+  return results;
+}
+function notifyCompletion(session) {
+  if (completionListeners.length === 0)
+    return;
+  const notification = {
+    sessionId: session.id,
+    command: session.command.slice(0, 200),
+    exitCode: session.exitCode ?? -1,
+    durationMs: Date.now() - session.startedAt,
+    stderrTail: session.stderr.slice(-10).join("\n"),
+    stdoutTail: session.stdout.slice(-10).join("\n")
+  };
+  for (const cb of completionListeners) {
+    try {
+      cb(notification);
+    } catch {
+    }
+  }
+}
 function createBackgroundExecTool(workspacePath) {
   return {
     name: "background_exec",
-    description: 'Run a shell command in the background. Returns immediately with a session ID. Use the "process" tool to poll for results, view logs, or kill the process. Ideal for long-running commands like dev servers, test suites, or builds.',
+    description: 'Run a shell command in the background. Returns immediately with a session ID. Use the "process" tool to poll for results, view logs, or kill the process. Ideal for long-running commands like dev servers, test suites, or builds. You will be automatically notified when the process completes.',
     inputSchema: {
       type: "object",
       properties: {
@@ -41014,7 +41096,8 @@ function createBackgroundExecTool(workspacePath) {
         exitCode: null,
         stdout: [],
         stderr: [],
-        process: child
+        process: child,
+        notified: false
       };
       child.stdout?.on("data", (chunk) => {
         const lines = chunk.toString().split("\n");
@@ -41032,16 +41115,20 @@ function createBackgroundExecTool(workspacePath) {
       });
       child.on("close", (code) => {
         session.exitCode = code ?? -1;
+        notifyCompletion(session);
       });
       child.on("exit", (code) => {
-        if (session.exitCode === null)
+        if (session.exitCode === null) {
           session.exitCode = code ?? -1;
+          notifyCompletion(session);
+        }
       });
       if (timeoutSec > 0) {
         setTimeout(() => {
           if (session.exitCode === null) {
             child.kill("SIGTERM");
             session.exitCode = -1;
+            notifyCompletion(session);
           }
         }, timeoutSec * 1e3);
       }
@@ -41147,12 +41234,13 @@ function createProcessTool() {
     }
   };
 }
-var sessions, sessionCounter;
+var sessions, sessionCounter, completionListeners;
 var init_process_manager = __esm({
   "../core/dist/tools/process-manager.js"() {
     "use strict";
     sessions = /* @__PURE__ */ new Map();
     sessionCounter = 0;
+    completionListeners = [];
   }
 });
 
@@ -41193,6 +41281,254 @@ var init_builtin = __esm({
   }
 });
 
+// ../core/dist/tools/subagent.js
+function buildToolMap(parentTools, allowedTools) {
+  const toolMap = /* @__PURE__ */ new Map();
+  if (allowedTools && allowedTools.length > 0) {
+    for (const name of allowedTools) {
+      const handler4 = parentTools.get(name);
+      if (handler4 && !BLOCKED_TOOLS.has(name)) {
+        toolMap.set(name, handler4);
+      }
+    }
+  } else {
+    for (const [name, handler4] of parentTools) {
+      if (!BLOCKED_TOOLS.has(name)) {
+        toolMap.set(name, handler4);
+      }
+    }
+  }
+  return toolMap;
+}
+async function runSubagentLoop(ctx, task, opts) {
+  const hardCap = ctx.maxToolIterations ?? DEFAULT_MAX_SUBAGENT_ITERATIONS;
+  const maxIter = Math.min(opts?.maxIterations ?? hardCap, hardCap);
+  const parentTools = ctx.getTools();
+  const provider = ctx.getProvider();
+  const contextWindow = ctx.llmRouter.getModelContextWindow(provider);
+  const toolMap = buildToolMap(parentTools, opts?.allowedTools);
+  const llmTools = [...toolMap.values()].map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema
+  }));
+  const systemContent = opts?.systemPrompt ?? "You are a focused subagent spawned to handle a specific subtask. Complete the task thoroughly and return a clear, concise result. Do not ask follow-up questions \u2014 work with what you have.";
+  let messages2 = [
+    { role: "system", content: systemContent },
+    { role: "user", content: task }
+  ];
+  log12.info("Subagent started", {
+    parentAgent: ctx.agentId,
+    taskLength: task.length,
+    toolCount: toolMap.size,
+    maxIterations: maxIter
+  });
+  let response = await ctx.llmRouter.chat({
+    messages: messages2,
+    tools: llmTools.length > 0 ? llmTools : void 0,
+    metadata: { agentId: ctx.agentId, sessionId: `subagent_${Date.now()}` }
+  }, provider);
+  let iterations = 0;
+  while (response.finishReason === "tool_use" && response.toolCalls?.length || response.finishReason === "max_tokens") {
+    if (++iterations > maxIter) {
+      log12.warn("Subagent hit max iterations", { parentAgent: ctx.agentId, iterations });
+      break;
+    }
+    if (response.finishReason === "max_tokens" && !response.toolCalls?.length) {
+      messages2.push({ role: "assistant", content: response.content });
+      messages2.push({
+        role: "user",
+        content: "[Continue from where you left off. Do not repeat what you already said.]"
+      });
+    } else {
+      messages2.push({
+        role: "assistant",
+        content: response.content,
+        toolCalls: response.toolCalls
+      });
+      for (const tc of response.toolCalls) {
+        const handler4 = toolMap.get(tc.name);
+        let result;
+        if (!handler4) {
+          result = JSON.stringify({ error: `Unknown tool: ${tc.name}` });
+        } else {
+          try {
+            result = await handler4.execute(tc.arguments);
+            result = ctx.offloadLargeResult(tc.name, result);
+          } catch (err) {
+            result = `Error: ${String(err)}`;
+          }
+        }
+        messages2.push({ role: "tool", content: result, toolCallId: tc.id });
+      }
+    }
+    messages2 = ctx.contextEngine.shrinkEphemeralMessages(messages2, contextWindow);
+    response = await ctx.llmRouter.chat({
+      messages: messages2,
+      tools: llmTools.length > 0 ? llmTools : void 0,
+      metadata: { agentId: ctx.agentId, sessionId: `subagent_${Date.now()}` }
+    }, provider);
+  }
+  log12.info("Subagent completed", {
+    parentAgent: ctx.agentId,
+    iterations,
+    resultLength: response.content.length
+  });
+  return response.content;
+}
+function createSubagentTool(ctx) {
+  return {
+    name: "spawn_subagent",
+    description: "Spawn a lightweight subagent with a clean, independent context to handle a focused subtask. The subagent inherits your tools but gets its own message history \u2014 it will not pollute your conversation. Use this to break down complex tasks: deep code analysis, research, file refactoring, test generation, etc. The subagent runs to completion and returns its final result to you. For running multiple subagents in parallel, use spawn_subagents instead.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "The focused task prompt for the subagent. Be specific about what you want it to do and what result to return."
+        },
+        system_prompt: {
+          type: "string",
+          description: "Optional custom system prompt for the subagent. Defaults to a focused task-execution prompt."
+        },
+        allowed_tools: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional subset of tool names the subagent can use. If omitted, it inherits all parent tools."
+        },
+        max_iterations: {
+          type: "number",
+          description: "Max tool iterations. Lower this for quick tasks."
+        }
+      },
+      required: ["task"]
+    },
+    async execute(args) {
+      const task = args["task"];
+      if (!task) {
+        return JSON.stringify({ status: "error", error: "task is required" });
+      }
+      try {
+        const result = await runSubagentLoop(ctx, task, {
+          systemPrompt: args["system_prompt"],
+          allowedTools: args["allowed_tools"],
+          maxIterations: args["max_iterations"]
+        });
+        return JSON.stringify({ status: "completed", result });
+      } catch (err) {
+        log12.error("Subagent execution failed", { error: String(err) });
+        return JSON.stringify({ status: "error", error: `Subagent failed: ${String(err)}` });
+      }
+    }
+  };
+}
+function createParallelSubagentTool(ctx) {
+  return {
+    name: "spawn_subagents",
+    description: "Spawn multiple subagents in PARALLEL, each with an independent context. All subagents run concurrently and their results are collected and returned together. Use this when you have multiple independent subtasks that can be worked on simultaneously: analyzing different files, researching different topics, implementing separate modules, etc. Each subagent gets its own clean message history and inherits your tools. IMPORTANT: Only use for truly independent tasks \u2014 subagents cannot communicate with each other.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+                description: 'A short identifier for this subtask (used to label results). E.g. "auth-review", "api-tests".'
+              },
+              task: {
+                type: "string",
+                description: "The focused task prompt for this subagent."
+              },
+              allowed_tools: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional subset of tools this subagent can use."
+              },
+              max_iterations: {
+                type: "number",
+                description: "Optional max iterations for this subagent."
+              }
+            },
+            required: ["id", "task"]
+          },
+          description: "Array of subtasks to execute in parallel. Each gets an independent subagent."
+        },
+        system_prompt: {
+          type: "string",
+          description: "Optional shared system prompt for all subagents."
+        }
+      },
+      required: ["tasks"]
+    },
+    async execute(args) {
+      const tasks2 = args["tasks"];
+      if (!tasks2 || !Array.isArray(tasks2) || tasks2.length === 0) {
+        return JSON.stringify({ status: "error", error: "tasks array is required and must not be empty" });
+      }
+      const MAX_PARALLEL = 10;
+      if (tasks2.length > MAX_PARALLEL) {
+        return JSON.stringify({
+          status: "error",
+          error: `Too many parallel subagents (${tasks2.length}). Maximum is ${MAX_PARALLEL}.`
+        });
+      }
+      const sharedSystemPrompt = args["system_prompt"];
+      log12.info("Spawning parallel subagents", {
+        parentAgent: ctx.agentId,
+        count: tasks2.length,
+        taskIds: tasks2.map((t) => t.id)
+      });
+      const startTime = Date.now();
+      const results = await Promise.allSettled(tasks2.map(async (t) => {
+        const result = await runSubagentLoop(ctx, t.task, {
+          systemPrompt: sharedSystemPrompt,
+          allowedTools: t.allowed_tools,
+          maxIterations: t.max_iterations
+        });
+        return { id: t.id, result };
+      }));
+      const output = results.map((r, i) => {
+        if (r.status === "fulfilled") {
+          return { id: r.value.id, status: "completed", result: r.value.result };
+        }
+        return { id: tasks2[i].id, status: "error", error: String(r.reason) };
+      });
+      const completed = output.filter((o) => o.status === "completed").length;
+      const failed = output.filter((o) => o.status === "error").length;
+      log12.info("Parallel subagents finished", {
+        parentAgent: ctx.agentId,
+        completed,
+        failed,
+        totalDurationMs: Date.now() - startTime
+      });
+      return JSON.stringify({
+        status: "completed",
+        summary: `${completed}/${tasks2.length} subagents completed successfully${failed > 0 ? `, ${failed} failed` : ""}`,
+        durationMs: Date.now() - startTime,
+        results: output
+      });
+    }
+  };
+}
+var log12, DEFAULT_MAX_SUBAGENT_ITERATIONS, BLOCKED_TOOLS;
+var init_subagent = __esm({
+  "../core/dist/tools/subagent.js"() {
+    "use strict";
+    init_dist();
+    log12 = createLogger("subagent");
+    DEFAULT_MAX_SUBAGENT_ITERATIONS = 200;
+    BLOCKED_TOOLS = /* @__PURE__ */ new Set([
+      "spawn_subagent",
+      "spawn_subagents",
+      "send_user_message",
+      "discover_tools"
+    ]);
+  }
+});
+
 // ../core/dist/concurrent/task-queue.js
 var TaskPriority, TaskStatus, TaskType, TaskQueue;
 var init_task_queue = __esm({
@@ -41907,12 +42243,12 @@ function hashString(str) {
 function noDetection() {
   return { detected: false, severity: "none", pattern: "", message: "" };
 }
-var log12, DEFAULT_CONFIG3, ToolLoopDetector;
+var log13, DEFAULT_CONFIG3, ToolLoopDetector;
 var init_tool_loop_detector = __esm({
   "../core/dist/tool-loop-detector.js"() {
     "use strict";
     init_dist();
-    log12 = createLogger("tool-loop-detector");
+    log13 = createLogger("tool-loop-detector");
     DEFAULT_CONFIG3 = {
       enabled: true,
       historySize: 30,
@@ -41982,12 +42318,12 @@ var init_tool_loop_detector = __esm({
         }
         if (streak >= this.config.criticalThreshold) {
           const msg = `Critical: "${last.name}" called ${streak} times with identical arguments`;
-          log12.warn(msg);
+          log13.warn(msg);
           return { detected: true, severity: "critical", pattern: "genericRepeat", message: msg };
         }
         if (streak >= this.config.warningThreshold) {
           const msg = `Warning: "${last.name}" called ${streak} times with identical arguments`;
-          log12.warn(msg);
+          log13.warn(msg);
           return { detected: true, severity: "warning", pattern: "genericRepeat", message: msg };
         }
         return noDetection();
@@ -42015,12 +42351,12 @@ var init_tool_loop_detector = __esm({
         }
         if (cycles >= Math.ceil(this.config.criticalThreshold / 2)) {
           const msg = `Critical: ping-pong pattern detected \u2014 "${recent[recent.length - 2].name}" \u2194 "${recent[recent.length - 1].name}" for ${cycles} cycles`;
-          log12.warn(msg);
+          log13.warn(msg);
           return { detected: true, severity: "critical", pattern: "pingPong", message: msg };
         }
         if (cycles >= Math.ceil(this.config.warningThreshold / 2)) {
           const msg = `Warning: ping-pong pattern \u2014 "${recent[recent.length - 2].name}" \u2194 "${recent[recent.length - 1].name}" for ${cycles} cycles`;
-          log12.warn(msg);
+          log13.warn(msg);
           return { detected: true, severity: "warning", pattern: "pingPong", message: msg };
         }
         return noDetection();
@@ -42044,12 +42380,12 @@ var init_tool_loop_detector = __esm({
         }
         if (sameResultStreak >= this.config.criticalThreshold) {
           const msg = `Critical: "${recent[recent.length - 1].name}" returned identical results ${sameResultStreak} times \u2014 no progress`;
-          log12.warn(msg);
+          log13.warn(msg);
           return { detected: true, severity: "critical", pattern: "noProgress", message: msg };
         }
         if (sameResultStreak >= this.config.warningThreshold) {
           const msg = `Warning: "${recent[recent.length - 1].name}" returned identical results ${sameResultStreak} times`;
-          log12.warn(msg);
+          log13.warn(msg);
           return { detected: true, severity: "warning", pattern: "noProgress", message: msg };
         }
         return noDetection();
@@ -42076,7 +42412,7 @@ function isErrorResult(result) {
     return false;
   }
 }
-var taskAsyncContext, log13, Agent;
+var taskAsyncContext, log14, Agent;
 var init_agent2 = __esm({
   "../core/dist/agent.js"() {
     "use strict";
@@ -42093,11 +42429,13 @@ var init_agent2 = __esm({
     init_environment_profile();
     init_tool_selector();
     init_builtin();
+    init_subagent();
+    init_process_manager();
     init_concurrent();
     init_task_queue();
     init_tool_loop_detector();
     taskAsyncContext = new AsyncLocalStorage();
-    log13 = createLogger("agent");
+    log14 = createLogger("agent");
     Agent = class _Agent {
       id;
       config;
@@ -42172,6 +42510,9 @@ var init_agent2 = __esm({
       static NETWORK_RETRY_BASE_MS = 2e3;
       static MEMORY_CONSOLIDATION_INTERVAL_MS = 4 * 60 * 60 * 1e3;
       // 4 hours
+      static DEFAULT_MAX_TOOL_ITERATIONS = 200;
+      _maxToolIterations;
+      _bgCompletionUnsub;
       constructor(options) {
         this.id = options.config.id || agentId();
         this.config = { ...options.config, id: this.id };
@@ -42189,6 +42530,7 @@ var init_agent2 = __esm({
         this.dataDir = options.dataDir;
         this.pathPolicy = options.pathPolicy;
         this.skillRegistry = options.skillRegistry;
+        this._maxToolIterations = options.maxToolIterations ?? _Agent.DEFAULT_MAX_TOOL_ITERATIONS;
         this.eventBus = new EventBus();
         this.memory = options.memory ?? new MemoryStore(options.dataDir);
         this.contextEngine = new ContextEngine();
@@ -42207,6 +42549,37 @@ var init_agent2 = __esm({
             this.tools.set(tool.name, tool);
           }
         }
+        const subagentCtx = {
+          llmRouter: this.llmRouter,
+          contextEngine: this.contextEngine,
+          getTools: () => taskAsyncContext.getStore()?.tools ?? this.tools,
+          getProvider: () => this.getEffectiveProvider(),
+          agentId: this.id,
+          offloadLargeResult: (toolName, result) => this.offloadLargeResult(toolName, result),
+          maxToolIterations: this._maxToolIterations
+        };
+        this.tools.set("spawn_subagent", createSubagentTool(subagentCtx));
+        this.tools.set("spawn_subagents", createParallelSubagentTool(subagentCtx));
+        this._bgCompletionUnsub = onBackgroundCompletion((notification) => {
+          const sessionId = this.currentSessionId;
+          if (!sessionId)
+            return;
+          const status = notification.exitCode === 0 ? "succeeded" : `failed (exit ${notification.exitCode})`;
+          const parts = [
+            `[BACKGROUND PROCESS COMPLETED] Session ${notification.sessionId} ${status}.`,
+            `Command: ${notification.command}`,
+            `Duration: ${Math.round(notification.durationMs / 1e3)}s`
+          ];
+          if (notification.exitCode !== 0 && notification.stderrTail) {
+            parts.push(`Stderr (last lines):
+${notification.stderrTail}`);
+          }
+          if (notification.exitCode === 0 && notification.stdoutTail) {
+            parts.push(`Output (last lines):
+${notification.stdoutTail}`);
+          }
+          this.injectUserMessage(sessionId, parts.join("\n"));
+        });
         this.taskExecutor = new TaskExecutor({
           agentId: this.id,
           maxConcurrentTasks: _Agent.MAX_CONCURRENT_TASKS,
@@ -42214,7 +42587,7 @@ var init_agent2 = __esm({
         });
         this.stateManager = new AgentStateManager(this.id, this.taskExecutor);
         this.eventBus.on("heartbeat:trigger", (ctx) => {
-          this.handleHeartbeat(ctx).catch((e) => log13.error("Heartbeat handler failed", { error: String(e) }));
+          this.handleHeartbeat(ctx).catch((e) => log14.error("Heartbeat handler failed", { error: String(e) }));
         });
         const roleFilePath = join6(this.dataDir, "role", "ROLE.md");
         this.toolHooks.register({
@@ -42223,13 +42596,13 @@ var init_agent2 = __esm({
             if ((ctx.toolName === "file_edit" || ctx.toolName === "file_write") && ctx.success) {
               const targetPath = ctx.arguments["path"] ?? ctx.arguments["filePath"] ?? "";
               if (targetPath === roleFilePath || targetPath.endsWith("/role/ROLE.md")) {
-                log13.info("Agent modified its own ROLE.md \u2014 reloading role definition");
+                log14.info("Agent modified its own ROLE.md \u2014 reloading role definition");
                 this.reloadRole();
               }
             }
           }
         });
-        log13.info(`Agent created: ${this.id}`, { name: this.config.name, role: this.role.name });
+        log14.info(`Agent created: ${this.id}`, { name: this.config.name, role: this.role.name });
       }
       /**
        * Resolve the LLM provider name for this agent.
@@ -42273,22 +42646,23 @@ var init_agent2 = __esm({
         try {
           this.environmentProfile = await detectEnvironment();
         } catch (e) {
-          log13.warn("Environment detection failed", { error: String(e) });
+          log14.warn("Environment detection failed", { error: String(e) });
         }
         const latestSession = this.memory.getLatestSession(this.id);
         if (latestSession && latestSession.messages.length > 0) {
           this.currentSessionId = latestSession.id;
-          log13.info(`Resumed session ${latestSession.id} with ${latestSession.messages.length} messages`);
+          log14.info(`Resumed session ${latestSession.id} with ${latestSession.messages.length} messages`);
         }
         this.heartbeat.start();
         this.memoryConsolidationTimer = setInterval(() => {
-          this.consolidateMemory().catch((e) => log13.warn("Memory consolidation failed", { error: String(e) }));
+          this.consolidateMemory().catch((e) => log14.warn("Memory consolidation failed", { error: String(e) }));
         }, _Agent.MEMORY_CONSOLIDATION_INTERVAL_MS);
         this.eventBus.emit("agent:started", { agentId: this.id });
-        log13.info(`Agent started: ${this.config.name}`);
+        log14.info(`Agent started: ${this.config.name}`);
       }
       async stop() {
         this.heartbeat.stop();
+        this._bgCompletionUnsub?.();
         if (this.memoryConsolidationTimer) {
           clearInterval(this.memoryConsolidationTimer);
           this.memoryConsolidationTimer = void 0;
@@ -42296,7 +42670,7 @@ var init_agent2 = __esm({
         this.metricsCollector.flush();
         this.setStatus("offline");
         this.eventBus.emit("agent:stopped", { agentId: this.id });
-        log13.info(`Agent stopped: ${this.config.name}`);
+        log14.info(`Agent stopped: ${this.config.name}`);
       }
       /**
        * Reload the agent's role from its ROLE.md file on disk.
@@ -42314,9 +42688,9 @@ var init_agent2 = __esm({
             name,
             systemPrompt: content
           };
-          log13.info(`Role reloaded from disk for agent ${this.config.name}`);
+          log14.info(`Role reloaded from disk for agent ${this.config.name}`);
         } catch (err) {
-          log13.warn(`Failed to reload role for agent ${this.config.name}`, { error: String(err) });
+          log14.warn(`Failed to reload role for agent ${this.config.name}`, { error: String(err) });
         }
       }
       /**
@@ -42326,7 +42700,7 @@ var init_agent2 = __esm({
       startNewSession() {
         const session = this.memory.createSession(this.id);
         this.currentSessionId = session.id;
-        log13.info(`New session started for agent ${this.config.name}: ${session.id}`);
+        log14.info(`New session started for agent ${this.config.name}: ${session.id}`);
       }
       /**
        * Bind the current in-memory session to a DB session ID (ses_*).
@@ -42336,7 +42710,7 @@ var init_agent2 = __esm({
       bindDbSession(dbSessionId) {
         if (this.currentSessionId) {
           this.dbSessionMap.set(dbSessionId, this.currentSessionId);
-          log13.debug(`Bound DB session ${dbSessionId} \u2192 memory session ${this.currentSessionId}`);
+          log14.debug(`Bound DB session ${dbSessionId} \u2192 memory session ${this.currentSessionId}`);
         }
       }
       /**
@@ -42350,7 +42724,7 @@ var init_agent2 = __esm({
           const session2 = this.memory.getSession(existingMemorySessionId);
           if (session2) {
             this.currentSessionId = existingMemorySessionId;
-            log13.debug(`Switched to existing memory session ${existingMemorySessionId} for DB session ${dbSessionId}`);
+            log14.debug(`Switched to existing memory session ${existingMemorySessionId} for DB session ${dbSessionId}`);
             return;
           }
           this.dbSessionMap.delete(dbSessionId);
@@ -42366,7 +42740,7 @@ var init_agent2 = __esm({
           }
         }
         this.currentSessionId = session.id;
-        log13.info(`Restored session context for DB session ${dbSessionId} \u2192 memory session ${session.id} (${dbMessages.length} messages)`);
+        log14.info(`Restored session context for DB session ${dbSessionId} \u2192 memory session ${session.id} (${dbMessages.length} messages)`);
       }
       pause(reason) {
         if (this.state.status === "offline")
@@ -42374,7 +42748,7 @@ var init_agent2 = __esm({
         this.pauseReason = reason;
         this.setStatus("paused");
         this.eventBus.emit("agent:paused", { agentId: this.id, reason });
-        log13.info(`Agent paused: ${this.config.name}`, { reason });
+        log14.info(`Agent paused: ${this.config.name}`, { reason });
       }
       resume() {
         if (this.state.status !== "paused")
@@ -42382,7 +42756,7 @@ var init_agent2 = __esm({
         this.pauseReason = void 0;
         this.setStatus(this.activeTasks.size > 0 ? "working" : "idle");
         this.eventBus.emit("agent:resumed", { agentId: this.id });
-        log13.info(`Agent resumed: ${this.config.name}`);
+        log14.info(`Agent resumed: ${this.config.name}`);
       }
       getPauseReason() {
         return this.pauseReason;
@@ -42397,7 +42771,7 @@ var init_agent2 = __esm({
           session = this.memory.getOrCreateSession(this.id, sessionId);
         }
         this.memory.appendMessage(sessionId, { role: "user", content });
-        log13.debug("Injected user message into session", { sessionId, contentLength: content.length });
+        log14.debug("Injected user message into session", { sessionId, contentLength: content.length });
       }
       /**
        * 执行聊天任务（高优先级）
@@ -42515,7 +42889,7 @@ var init_agent2 = __esm({
       cancelActiveStream() {
         if (this.activeStreamToken) {
           this.activeStreamToken.cancelled = true;
-          log13.info("Active stream cancelled", { agentId: this.id });
+          log14.info("Active stream cancelled", { agentId: this.id });
         }
       }
       /** Get a cancel token for the current stream */
@@ -42681,7 +43055,7 @@ ${conversationText}`
         const profile = this.config.profile;
         if (profile?.maxTokensPerDay !== void 0 && profile.maxTokensPerDay !== null && this.state.tokensUsedToday >= profile.maxTokensPerDay) {
           this.setStatus("paused");
-          log13.warn("Agent paused: daily token budget exceeded", {
+          log14.warn("Agent paused: daily token budget exceeded", {
             agentId: this.id,
             tokensUsedToday: this.state.tokensUsedToday,
             maxTokensPerDay: profile.maxTokensPerDay
@@ -42716,9 +43090,15 @@ ${conversationText}`
         this.notifyStateChange();
         if (wasPausedByBudget) {
           this.setStatus("idle");
-          log13.info("Agent resumed after daily token reset", { agentId: this.id });
+          log14.info("Agent resumed after daily token reset", { agentId: this.id });
         }
       }
+      get maxToolIterations() {
+        return this._maxToolIterations;
+      }
+      set maxToolIterations(value) {
+        this._maxToolIterations = Math.max(1, Math.min(value, 1e4));
+      }
       setOrgContext(ctx) {
         this.orgContext = ctx;
       }
@@ -42980,7 +43360,7 @@ No recent activity recorded.`,
 ${report}`);
           return report;
         } catch (error) {
-          log13.error("Failed to generate daily report", { error: String(error) });
+          log14.error("Failed to generate daily report", { error: String(error) });
           return `Unable to generate report: ${String(error)}`;
         }
       }
@@ -43102,7 +43482,7 @@ ${report}`);
             toolDefinitions: llmTools
           });
           messages2 = prepared.messages;
-          log13.debug("Context usage for chat", { usagePercent: prepared.usage.usagePercent, totalUsed: prepared.usage.totalUsed });
+          log14.debug("Context usage for chat", { usagePercent: prepared.usage.usagePercent, totalUsed: prepared.usage.totalUsed });
         }
         const useCompaction = this.llmRouter.isCompactionSupported(this.getEffectiveProvider());
         try {
@@ -43124,11 +43504,10 @@ ${report}`);
             durationMs: Date.now() - llmStart,
             success: true
           });
-          const MAX_TOOL_ITERATIONS = 200;
           let toolIterations = 0;
           while (response.finishReason === "tool_use" && response.toolCalls?.length || response.finishReason === "max_tokens") {
-            if (++toolIterations > MAX_TOOL_ITERATIONS) {
-              log13.warn("Tool loop hit max iterations", {
+            if (++toolIterations > this._maxToolIterations) {
+              log14.warn("Tool loop hit max iterations", {
                 agentId: this.id,
                 iterations: toolIterations
               });
@@ -43239,7 +43618,7 @@ ${report}`);
               const loopCheck = this.loopDetector.check();
               if (loopCheck.detected) {
                 if (loopCheck.severity === "critical") {
-                  log13.warn("Loop detector: critical pattern \u2014 breaking", {
+                  log14.warn("Loop detector: critical pattern \u2014 breaking", {
                     agentId: this.id,
                     pattern: loopCheck.pattern
                   });
@@ -43335,7 +43714,7 @@ ${report}`);
             success: false,
             detail: String(error)
           });
-          log13.error("Failed to handle message", { error: String(error) });
+          log14.error("Failed to handle message", { error: String(error) });
           throw error;
         }
       }
@@ -43401,7 +43780,7 @@ ${report}`);
           toolDefinitions: llmTools
         });
         const messages2 = preparedStream.messages;
-        log13.debug("Context usage for stream", { usagePercent: preparedStream.usage.usagePercent });
+        log14.debug("Context usage for stream", { usagePercent: preparedStream.usage.usagePercent });
         const useCompaction = this.llmRouter.isCompactionSupported(this.getEffectiveProvider());
         const abortController = new AbortController();
         let cancelPollTimer;
@@ -43431,14 +43810,14 @@ ${report}`);
           let streamToolIterations = 0;
           while (response.finishReason === "tool_use" && response.toolCalls?.length || response.finishReason === "max_tokens") {
             if (++streamToolIterations > MAX_STREAM_TOOL_ITERATIONS) {
-              log13.warn("Stream tool loop hit max iterations", {
+              log14.warn("Stream tool loop hit max iterations", {
                 agentId: this.id,
                 iterations: streamToolIterations
               });
               break;
             }
             if (cancelToken?.cancelled) {
-              log13.info("Stream cancelled by user during tool loop", { agentId: this.id });
+              log14.info("Stream cancelled by user during tool loop", { agentId: this.id });
               if (lastResponseContent && this.currentSessionId) {
                 this.memory.appendMessage(this.currentSessionId, {
                   role: "assistant",
@@ -43512,7 +43891,7 @@ ${report}`);
               }
               const loopCheck = this.loopDetector.check();
               if (loopCheck.detected && loopCheck.severity === "critical") {
-                log13.warn("Stream loop detector: critical pattern \u2014 injecting warning", {
+                log14.warn("Stream loop detector: critical pattern \u2014 injecting warning", {
                   agentId: this.id,
                   pattern: loopCheck.pattern
                 });
@@ -43533,7 +43912,7 @@ ${report}`);
             });
             const updatedMessages = preparedCont.messages;
             if (cancelToken?.cancelled) {
-              log13.info("Stream cancelled before LLM re-call", { agentId: this.id });
+              log14.info("Stream cancelled before LLM re-call", { agentId: this.id });
               if (lastResponseContent && this.currentSessionId) {
                 this.memory.appendMessage(this.currentSessionId, {
                   role: "assistant",
@@ -43617,7 +43996,7 @@ ${report}`);
             success: false,
             detail: String(error)
           });
-          log13.error("Failed to handle stream message", { error: String(error) });
+          log14.error("Failed to handle stream message", { error: String(error) });
           throw error;
         } finally {
           if (cancelPollTimer)
@@ -43686,6 +44065,30 @@ ${report}`);
           onLog({ seq: -1, type: "text_delta", content: text2, persist: false });
         };
         emit("status", "started", { agentId: this.id, agentName: this.config.name });
+        let createdWorktreePath;
+        if (taskWorkspace && taskWorkspace.branch) {
+          const repoRoot = taskWorkspace.worktreePath;
+          const isolatedPath = join6(repoRoot, ".worktrees", `task-${taskId2}`);
+          try {
+            const { exec: execCb3 } = await import("node:child_process");
+            const { promisify: promisify4 } = await import("node:util");
+            const execAsync3 = promisify4(execCb3);
+            await execAsync3(`git worktree add "${isolatedPath}" -b "${taskWorkspace.branch}" "${taskWorkspace.baseBranch}"`, { cwd: repoRoot });
+            taskWorkspace = { ...taskWorkspace, worktreePath: isolatedPath };
+            createdWorktreePath = isolatedPath;
+            emit("status", `worktree created: ${isolatedPath}`, { branch: taskWorkspace.branch });
+            log14.info("Git worktree created for task", { taskId: taskId2, path: isolatedPath, branch: taskWorkspace.branch });
+          } catch (wtErr) {
+            const msg = String(wtErr.message ?? wtErr);
+            if (msg.includes("already exists")) {
+              taskWorkspace = { ...taskWorkspace, worktreePath: isolatedPath };
+              createdWorktreePath = isolatedPath;
+              log14.warn("Worktree already exists, reusing", { taskId: taskId2, path: isolatedPath });
+            } else {
+              log14.warn("Failed to create worktree, falling back to repo root", { taskId: taskId2, error: msg });
+            }
+          }
+        }
         if (taskWorkspace) {
           const worktreePolicy = {
             primaryWorkspace: taskWorkspace.worktreePath,
@@ -43710,7 +44113,7 @@ ${report}`);
           if (ctx) {
             ctx.tools = taskLocalTools;
           }
-          log13.info("Tools rebound to worktree workspace (task-local)", {
+          log14.info("Tools rebound to worktree workspace (task-local)", {
             taskId: taskId2,
             agentId: this.id,
             worktreePath: taskWorkspace.worktreePath
@@ -43837,7 +44240,7 @@ ${report}`);
             toolDefinitions: llmTools
           });
           const messages2 = preparedTask.messages;
-          log13.debug("Context usage for task execution", { taskId: taskId2, usagePercent: preparedTask.usage.usagePercent, totalUsed: preparedTask.usage.totalUsed });
+          log14.debug("Context usage for task execution", { taskId: taskId2, usagePercent: preparedTask.usage.usagePercent, totalUsed: preparedTask.usage.totalUsed });
           let taskLlmStart = Date.now();
           let response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages: messages2, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(sessionId), compaction: useCompaction }, (event) => {
             if (event.type === "text_delta" && event.text) {
@@ -43854,7 +44257,7 @@ ${report}`);
             if (cancelToken?.cancelled) {
               flushText();
               emit("status", "cancelled", { reason: "Task execution was stopped externally" });
-              log13.info("Task execution cancelled externally", { taskId: taskId2, agentId: this.id });
+              log14.info("Task execution cancelled externally", { taskId: taskId2, agentId: this.id });
               return;
             }
             flushText();
@@ -43906,7 +44309,7 @@ ${report}`);
             }
             if (cancelToken?.cancelled) {
               emit("status", "cancelled", { reason: "Task execution was stopped externally" });
-              log13.info("Task execution cancelled externally after tools", { taskId: taskId2, agentId: this.id });
+              log14.info("Task execution cancelled externally after tools", { taskId: taskId2, agentId: this.id });
               return;
             }
             if (taskToolIterations > 0 && taskToolIterations % 10 === 0) {
@@ -43921,7 +44324,7 @@ ${report}`);
                   "- Use `task_note` to record progress before submitting."
                 ].join("\n")
               });
-              log13.debug("Injected task completion reminder", { taskId: taskId2, iteration: taskToolIterations });
+              log14.debug("Injected task completion reminder", { taskId: taskId2, iteration: taskToolIterations });
             }
             const preparedTaskCont = await this.contextEngine.prepareMessages({
               systemPrompt,
@@ -43953,7 +44356,7 @@ ${report}`);
           if (cancelToken?.cancelled) {
             flushText();
             emit("status", "cancelled", { reason: "Task execution was stopped externally" });
-            log13.info("Task execution cancelled externally after completion", { taskId: taskId2, agentId: this.id });
+            log14.info("Task execution cancelled externally after completion", { taskId: taskId2, agentId: this.id });
             return;
           }
           flushText();
@@ -43962,12 +44365,12 @@ ${report}`);
           emit("status", "execution_finished", {});
           this.metricsCollector.recordTaskCompletion(taskId2, "completed", Date.now() - taskStartMs);
           this.eventBus.emit("task:completed", { taskId: taskId2, agentId: this.id });
-          log13.info("Task execution finished", { taskId: taskId2, agentId: this.id });
+          log14.info("Task execution finished", { taskId: taskId2, agentId: this.id });
         } catch (error) {
           if (cancelToken?.cancelled) {
             flushText();
             emit("status", "cancelled", { reason: "Task execution was stopped externally" });
-            log13.info("Task execution cancelled (caught abort)", { taskId: taskId2, agentId: this.id });
+            log14.info("Task execution cancelled (caught abort)", { taskId: taskId2, agentId: this.id });
             return;
           }
           if (textBuffer.trim()) {
@@ -43985,7 +44388,7 @@ ${report}`);
             success: false,
             detail: String(error)
           });
-          log13.error("Task execution failed", { taskId: taskId2, agentId: this.id, error: String(error) });
+          log14.error("Task execution failed", { taskId: taskId2, agentId: this.id, error: String(error) });
           this.eventBus.emit("task:failed", { taskId: taskId2, agentId: this.id, error: String(error) });
           taskFailed = String(error);
           throw error;
@@ -44214,7 +44617,7 @@ ${report}`);
         for (const tool of updatedTools) {
           this.tools.set(tool.name, tool);
         }
-        log13.info("Granted read-only access", { agentId: this.id, path });
+        log14.info("Granted read-only access", { agentId: this.id, path });
       }
       /**
        * Remove a previously granted read-only path and rebuild tools.
@@ -44235,7 +44638,7 @@ ${report}`);
         for (const tool of updatedTools) {
           this.tools.set(tool.name, tool);
         }
-        log13.info("Revoked read-only access", { agentId: this.id, path });
+        log14.info("Revoked read-only access", { agentId: this.id, path });
       }
       getState() {
         const state = { ...this.state };
@@ -44354,7 +44757,7 @@ ${report}`);
           }
           try {
             const result2 = await this.skillInstaller(args);
-            log13.info("Skill installed via discover_tools", { agentId: this.id, skill: skillName, method: result2.method });
+            log14.info("Skill installed via discover_tools", { agentId: this.id, skill: skillName, method: result2.method });
             return JSON.stringify({
               status: "ok",
               installed: result2.name,
@@ -44392,7 +44795,7 @@ ${report}`);
                   this.activateTools(toolNames);
                   mcpToolCount = mcpTools.length;
                 } catch (err) {
-                  log13.warn("Failed to activate skill MCP servers via discover_tools", {
+                  log14.warn("Failed to activate skill MCP servers via discover_tools", {
                     agentId: this.id,
                     skill: name,
                     error: String(err)
@@ -44407,7 +44810,7 @@ ${report}`);
               if (!skill.manifest.instructions && mcpToolCount === 0)
                 parts.push("skill found but has no instructions or MCP tools");
               activated.push(parts.length > 1 ? `${parts[0]} (${parts.slice(1).join(", ")})` : parts[0]);
-              log13.info("Skill activated via discover_tools", {
+              log14.info("Skill activated via discover_tools", {
                 agentId: this.id,
                 skill: name,
                 mcpToolCount,
@@ -44443,7 +44846,7 @@ ${report}`);
           }
           try {
             const result = await this.userMessageSender(message);
-            log13.info("Proactive message sent to user", { agentId: this.id, sessionId: result.sessionId });
+            log14.info("Proactive message sent to user", { agentId: this.id, sessionId: result.sessionId });
             return JSON.stringify({ status: "ok", sessionId: result.sessionId, messageId: result.messageId });
           } catch (err) {
             return JSON.stringify({ status: "error", message: `Failed to send message: ${String(err)}` });
@@ -44467,7 +44870,7 @@ ${report}`);
         const needsApproval = this.config.profile?.requireApprovalFor?.some((pattern) => toolCall.name === pattern || toolCall.name.startsWith(pattern.replace("*", "")));
         if (needsApproval) {
           if (this.approvalCallback) {
-            log13.info(`Tool ${toolCall.name} requires approval, requesting...`, { agentId: this.id });
+            log14.info(`Tool ${toolCall.name} requires approval, requesting...`, { agentId: this.id });
             const approved = await this.approvalCallback({
               agentId: this.id,
               agentName: this.config.name,
@@ -44476,15 +44879,15 @@ ${report}`);
               reason: `Agent wants to execute '${toolCall.name}'`
             });
             if (!approved) {
-              log13.info(`Tool ${toolCall.name} execution denied by human`, { agentId: this.id });
+              log14.info(`Tool ${toolCall.name} execution denied by human`, { agentId: this.id });
               return JSON.stringify({
                 status: "denied",
                 error: `Execution of '${toolCall.name}' was denied by human reviewer`
               });
             }
-            log13.info(`Tool ${toolCall.name} approved by human`, { agentId: this.id });
+            log14.info(`Tool ${toolCall.name} approved by human`, { agentId: this.id });
           } else {
-            log13.warn(`Tool ${toolCall.name} requires approval but no approval callback set`, {
+            log14.warn(`Tool ${toolCall.name} requires approval but no approval callback set`, {
               agentId: this.id
             });
           }
@@ -44525,10 +44928,10 @@ ${report}`);
           try {
             if (attempt > 0) {
               const delay = _Agent.TOOL_RETRY_BASE_MS * Math.pow(2, attempt - 1);
-              log13.info(`Retrying tool ${toolCall.name} (attempt ${attempt + 1})`, { delay });
+              log14.info(`Retrying tool ${toolCall.name} (attempt ${attempt + 1})`, { delay });
               await new Promise((r) => setTimeout(r, delay));
             }
-            log13.debug(`Executing tool: ${toolCall.name}`, { args: effectiveArgs, attempt });
+            log14.debug(`Executing tool: ${toolCall.name}`, { args: effectiveArgs, attempt });
             const span = startSpan("agent.tool", { tool: toolCall.name, attempt });
             try {
               const result = await handler4.execute(effectiveArgs, onOutput);
@@ -44551,7 +44954,7 @@ ${report}`);
             }
           } catch (error) {
             lastError = error;
-            log13.error(`Tool execution failed: ${toolCall.name} (attempt ${attempt + 1})`, {
+            log14.error(`Tool execution failed: ${toolCall.name} (attempt ${attempt + 1})`, {
               error: String(error)
             });
           }
@@ -44563,7 +44966,7 @@ ${report}`);
       handleFailure(reason) {
         this.consecutiveFailures++;
         if (this.consecutiveFailures >= _Agent.MAX_CONSECUTIVE_FAILURES) {
-          log13.warn("Consecutive failure threshold reached, escalating to human", {
+          log14.warn("Consecutive failure threshold reached, escalating to human", {
             agentId: this.id,
             failures: this.consecutiveFailures
           });
@@ -44588,7 +44991,7 @@ ${report}`);
               throw error;
             }
             const delay = _Agent.NETWORK_RETRY_BASE_MS * Math.pow(2, attempt);
-            log13.warn(`${label} failed with network error, retrying (${attempt + 1}/${_Agent.NETWORK_RETRY_MAX})`, {
+            log14.warn(`${label} failed with network error, retrying (${attempt + 1}/${_Agent.NETWORK_RETRY_MAX})`, {
               agentId: this.id,
               error: String(error).slice(0, 200),
               delay
@@ -44612,7 +45015,7 @@ ${report}`);
         }
       }
       async handleHeartbeat(ctx) {
-        log13.info("Processing heartbeat check-in");
+        log14.info("Processing heartbeat check-in");
         const activityId = this.startActivity("heartbeat", "Heartbeat check-in", {});
         let lastHeartbeatSummary = "";
         try {
@@ -44664,10 +45067,12 @@ ${todayLog.slice(0, 3e3)}
             '- **type**: "file"',
             "- **Content must be concise, clear, and accurate**:",
             "  1. **My work today**: What you personally accomplished (tasks reviewed, approved/rejected, decisions made)",
-            "  2. **Team progress**: What each team member accomplished today (cross-reference with activity log)",
-            "  3. **Blockers & risks**: Anything stalled or at risk",
-            "  4. **Plan for tomorrow**: Top priorities for the next day",
+            "  2. **My team progress**: What each member of YOUR team accomplished today (use `team_status` to check). Focus on your own team only.",
+            "  3. **Cross-team interactions**: Any coordination with other teams (if applicable)",
+            "  4. **Blockers & risks**: Anything stalled or at risk within your team",
+            "  5. **Plan for tomorrow**: Top priorities for the next day",
             "- Keep it under 500 words. No filler. Every sentence must carry information.",
+            "- IMPORTANT: Only report on YOUR team. Do NOT report on agents from other teams.",
             "- If no meaningful activity happened today, say so honestly \u2014 do not fabricate work.",
             "- The system will automatically mark the report as created after this heartbeat.",
             ""
@@ -44687,26 +45092,67 @@ ${todayLog.slice(0, 3e3)}
           "Quality bar: Only record insights that are **specific**, **actionable**, and **non-obvious**.",
           "Skip if nothing meaningful happened since last heartbeat."
         ].join("\n");
+        const bgCompletions = drainCompletedNotifications();
+        let bgCompletionSection = "";
+        if (bgCompletions.length > 0) {
+          const lines = bgCompletions.map((n) => {
+            const status = n.exitCode === 0 ? "OK" : `FAILED (exit ${n.exitCode})`;
+            return `- [${status}] \`${n.command}\` (${Math.round(n.durationMs / 1e3)}s)${n.exitCode !== 0 && n.stderrTail ? `
+  stderr: ${n.stderrTail.slice(0, 200)}` : ""}`;
+          });
+          bgCompletionSection = [
+            "",
+            "## Background Processes Completed",
+            `${bgCompletions.length} background process(es) finished since last check:`,
+            ...lines,
+            "Review any failures and take action if needed."
+          ].join("\n");
+        }
         const prompt = [
           "[HEARTBEAT CHECK-IN]",
           "",
           "## Your Checklist",
           checklist,
           lastHeartbeatSummary,
+          bgCompletionSection,
           failedTaskRecoverySection,
           dailyReportSection,
           selfEvolutionSection,
           "",
-          "## Rules",
+          "## Core Principle: Patrol, Don't Build",
+          "Heartbeat is a patrol \u2014 observe, triage, and take lightweight actions. Heavy work belongs in tasks.",
+          "",
+          "## What You CAN Do (lightweight actions)",
+          "- **Check status**: `task_list`, `task_get`, `team_status` \u2014 see what's going on",
+          "- **Send messages**: `agent_send_message`, `send_user_message` \u2014 notify people of issues or updates",
+          "- **Create tasks**: `task_create` \u2014 if you spot something that needs doing, create a task for it (assign to yourself or others)",
+          '- **Trigger existing tasks**: `task_update(status: "in_progress")` \u2014 restart failed tasks or unblock stuck ones',
+          '- **Retry failed tasks**: If tasks assigned to you are in `failed` status, retry via `task_update(status: "in_progress")` with a note',
+          "- **Quick reviews**: If tasks are in `review` where you are the reviewer, review them now (may need more tool calls)",
+          "- **Save insights**: `memory_save` \u2014 record observations, lessons, and patterns",
+          "- **Propose requirements**: `requirement_propose` \u2014 suggest work based on what you observe",
+          "",
+          "## What You Must NOT Do",
+          "- **No complex multi-step implementation** \u2014 don't write code, refactor modules, or do deep analysis in heartbeat",
+          "- If you identify something complex that needs doing:",
+          "  1. Notify the user via `send_user_message` explaining what you found and why it matters",
+          "  2. Create a task via `task_create` with clear description and acceptance criteria",
+          "  3. The user will approve and the task system handles execution",
+          "",
+          "## Conditional Actions",
+          "- If background processes failed \u2192 check the error, notify the responsible developer or user",
+          "- If tasks are blocked for too long \u2192 investigate blockers, send a message to the assignee or PM",
+          "- If a dependency task completed \u2192 check if downstream tasks can be unblocked",
+          "- If you notice a recurring pattern \u2192 save it as a lesson via `memory_save`",
+          "",
+          "## Finishing Up",
           "- Compare against your last heartbeat summary above. Skip unchanged items.",
-          "- For routine checks: max 5 tool calls. This is monitoring, not a work session.",
-          "- **Exception \u2014 review duty**: If you find tasks in `review` where you are the reviewer, you MUST review them now. Reviews may require more tool calls (task_get, file_read, task_note, task_update). Complete the review fully.",
-          '- **Exception \u2014 failed tasks**: If you find tasks assigned to you in `failed` status, retry them via `task_update(status: "in_progress")` with a note.',
-          "- **Exception \u2014 daily report**: If the Daily Report Required section is present above, you MUST produce the report. This may require additional tool calls.",
-          "- At the end, call `memory_save` with key `heartbeat:summary` \u2014 one line per finding.",
+          "- If the Daily Report Required section is present above, you MUST produce the report.",
+          "- Call `memory_save` with key `heartbeat:summary` \u2014 one line per finding.",
           "- If nothing needs attention and no daily report is due, respond with exactly: HEARTBEAT_OK"
         ].join("\n");
         const baseTools = [
+          "task_create",
           "task_list",
           "task_update",
           "task_get",
@@ -44759,7 +45205,7 @@ ${todayLog.slice(0, 3e3)}
             lastError = error;
             if (attempt < HEARTBEAT_MAX_RETRIES) {
               const delay = HEARTBEAT_RETRY_BASE_MS * Math.pow(2, attempt);
-              log13.warn(`Heartbeat attempt ${attempt + 1}/${HEARTBEAT_MAX_RETRIES + 1} failed, retrying in ${delay}ms`, {
+              log14.warn(`Heartbeat attempt ${attempt + 1}/${HEARTBEAT_MAX_RETRIES + 1} failed, retrying in ${delay}ms`, {
                 agentId: this.id,
                 error: String(error).slice(0, 200)
               });
@@ -44770,7 +45216,7 @@ ${todayLog.slice(0, 3e3)}
         this.emitActivityLog(activityId, "error", String(lastError));
         this.endActivity(activityId);
         this.metricsCollector.recordHeartbeat(false);
-        log13.error("Heartbeat failed after all retries", {
+        log14.error("Heartbeat failed after all retries", {
           agentId: this.id,
           attempts: HEARTBEAT_MAX_RETRIES + 1,
           error: String(lastError)
@@ -44809,9 +45255,9 @@ ${todayLog.slice(0, 3e3)}
             maxHistory: 25,
             scenario: "heartbeat"
           });
-          log13.info("Memory flush completed before compaction", { agentId: this.id, sessionId });
+          log14.info("Memory flush completed before compaction", { agentId: this.id, sessionId });
         } catch (error) {
-          log13.warn("Memory flush failed, proceeding with compaction anyway", { error: String(error) });
+          log14.warn("Memory flush failed, proceeding with compaction anyway", { error: String(error) });
         }
       }
       /**
@@ -44829,7 +45275,7 @@ ${todayLog.slice(0, 3e3)}
               await this.memoryFlush(this.currentSessionId);
               const { flushedCount } = this.memory.compactSession(this.currentSessionId, 15);
               if (flushedCount > 0) {
-                log13.info("Memory consolidation: compacted main session", {
+                log14.info("Memory consolidation: compacted main session", {
                   agentId: this.id,
                   flushedCount,
                   remaining: session.messages.length
@@ -44843,9 +45289,9 @@ ${todayLog.slice(0, 3e3)}
             await this.dreamConsolidateMemory(entries2);
             this.pruneMemoryMd();
           }
-          log13.debug("Memory consolidation completed", { agentId: this.id });
+          log14.debug("Memory consolidation completed", { agentId: this.id });
         } catch (error) {
-          log13.warn("Memory consolidation failed", { agentId: this.id, error: String(error) });
+          log14.warn("Memory consolidation failed", { agentId: this.id, error: String(error) });
         }
       }
       /**
@@ -44861,7 +45307,7 @@ ${todayLog.slice(0, 3e3)}
           return `[${i}] id=${e.id} type=${e.type} date=${e.timestamp?.slice(0, 10) ?? "?"}${tags}
 ${e.content.slice(0, 200)}`;
         }).join("\n\n");
-        log13.info("Dream cycle starting", {
+        log14.info("Dream cycle starting", {
           agentId: this.id,
           totalEntries: entries2.length,
           batchSize: batch.length,
@@ -44900,11 +45346,11 @@ ${e.content.slice(0, 200)}`;
           });
           const jsonMatch = response.match(/\{[\s\S]*\}/);
           if (!jsonMatch) {
-            log13.debug("Dream cycle: no valid JSON in response, skipping");
+            log14.debug("Dream cycle: no valid JSON in response, skipping");
             return;
           }
           const plan = JSON.parse(jsonMatch[0]);
-          log13.info("Dream cycle plan", {
+          log14.info("Dream cycle plan", {
             agentId: this.id,
             toRemove: plan.remove?.length ?? 0,
             toMerge: plan.merge?.length ?? 0,
@@ -44946,7 +45392,7 @@ ${e.content.slice(0, 200)}`;
             }
           }
           if (removedCount > 0 || mergedCount > 0) {
-            log13.info("Dream cycle completed", {
+            log14.info("Dream cycle completed", {
               agentId: this.id,
               entriesBefore: entries2.length,
               removed: removedCount,
@@ -44954,10 +45400,10 @@ ${e.content.slice(0, 200)}`;
               entriesAfter: this.memory.getEntries().length
             });
           } else {
-            log13.debug("Dream cycle: no changes needed", { agentId: this.id });
+            log14.debug("Dream cycle: no changes needed", { agentId: this.id });
           }
         } catch (error) {
-          log13.warn("Dream cycle failed", { agentId: this.id, error: String(error) });
+          log14.warn("Dream cycle failed", { agentId: this.id, error: String(error) });
         }
       }
       /**
@@ -45000,7 +45446,7 @@ ${e.content.slice(0, 200)}`;
         if (pruned !== content.trim()) {
           const memoryMdPath = join6(this.dataDir, "MEMORY.md");
           writeFileSync7(memoryMdPath, pruned + "\n");
-          log13.info("Pruned MEMORY.md: removed daily-report sections and LLM artifacts", { agentId: this.id });
+          log14.info("Pruned MEMORY.md: removed daily-report sections and LLM artifacts", { agentId: this.id });
         }
       }
     };
@@ -45158,12 +45604,12 @@ ${sharedContent}` : roleContent;
 
 // ../core/dist/tools/mcp-client.js
 import { spawn as spawn3 } from "node:child_process";
-var log14, MCPClientManager;
+var log15, MCPClientManager;
 var init_mcp_client = __esm({
   "../core/dist/tools/mcp-client.js"() {
     "use strict";
     init_dist();
-    log14 = createLogger("mcp-client");
+    log15 = createLogger("mcp-client");
     MCPClientManager = class _MCPClientManager {
       servers = /* @__PURE__ */ new Map();
       requestId = 0;
@@ -45179,31 +45625,31 @@ var init_mcp_client = __esm({
       async connectByKey(key2, displayName, config) {
         const existing = this.servers.get(key2);
         if (existing) {
-          log14.info(`MCP server ${displayName} already connected, reusing (${existing.tools.length} tools)`);
+          log15.info(`MCP server ${displayName} already connected, reusing (${existing.tools.length} tools)`);
           return existing.tools;
         }
-        log14.info(`Connecting to MCP server: ${displayName}`, { command: config.command, key: key2 });
+        log15.info(`Connecting to MCP server: ${displayName}`, { command: config.command, key: key2 });
         const proc = spawn3(config.command, config.args ?? [], {
           stdio: ["pipe", "pipe", "pipe"],
           env: { ...process.env, ...config.env }
         });
         proc.on("error", (err) => {
-          log14.error(`MCP server ${displayName} error`, { error: String(err) });
+          log15.error(`MCP server ${displayName} error`, { error: String(err) });
         });
         const stderrChunks = [];
         proc.stderr?.on("data", (data) => {
           const text2 = data.toString();
           stderrChunks.push(text2);
           if (stderrChunks.length <= 5) {
-            log14.warn(`MCP server ${displayName} stderr`, { text: text2.trimEnd() });
+            log15.warn(`MCP server ${displayName} stderr`, { text: text2.trimEnd() });
           }
         });
         proc.on("exit", (code) => {
           const stderr = stderrChunks.join("").trim();
           if (stderr) {
-            log14.error(`MCP server ${displayName} exited with stderr`, { code, stderr: stderr.slice(0, 500) });
+            log15.error(`MCP server ${displayName} exited with stderr`, { code, stderr: stderr.slice(0, 500) });
           } else {
-            log14.info(`MCP server ${displayName} exited`, { code });
+            log15.info(`MCP server ${displayName} exited`, { code });
           }
           this.servers.delete(key2);
           this.stdoutBuffers.delete(proc);
@@ -45227,7 +45673,7 @@ var init_mcp_client = __esm({
           const toolsResult = await this.sendRequest(proc, "tools/list", {});
           const tools = toolsResult?.tools ?? [];
           this.servers.set(key2, { process: proc, tools });
-          log14.info(`MCP server ${displayName} connected with ${tools.length} tools`);
+          log15.info(`MCP server ${displayName} connected with ${tools.length} tools`);
           return tools;
         } catch (err) {
           proc.kill();
@@ -45302,7 +45748,7 @@ var init_mcp_client = __esm({
           server.process.kill();
           this.servers.delete(name);
           this.stdoutBuffers.delete(server.process);
-          log14.info(`MCP server disconnected: ${name}`);
+          log15.info(`MCP server disconnected: ${name}`);
         }
       }
       async disconnectServerScoped(name, scopeId) {
@@ -45379,12 +45825,12 @@ var init_mcp_client = __esm({
 });
 
 // ../core/dist/tools/browser-session.js
-var log15, TARGET_ID_PARAM_NAMES, BrowserSessionManager;
+var log16, TARGET_ID_PARAM_NAMES, BrowserSessionManager;
 var init_browser_session = __esm({
   "../core/dist/tools/browser-session.js"() {
     "use strict";
     init_dist();
-    log15 = createLogger("browser-session");
+    log16 = createLogger("browser-session");
     TARGET_ID_PARAM_NAMES = ["targetId", "id", "pageId", "target"];
     BrowserSessionManager = class {
       /** agentId → set of owned target/page IDs */
@@ -45468,7 +45914,7 @@ var init_browser_session = __esm({
             const owned = this.getOwned(agentId2);
             for (const id of ids) {
               owned.add(id);
-              log15.debug(`Page ${id} assigned to agent ${agentId2}`);
+              log16.debug(`Page ${id} assigned to agent ${agentId2}`);
             }
             return result;
           }
@@ -45491,7 +45937,7 @@ var init_browser_session = __esm({
                   return owned.has(id);
                 });
                 if (parsed.length !== filtered.length) {
-                  log15.debug(`list_pages: agent ${agentId2} sees ${filtered.length}/${parsed.length} pages (strict ownership filter)`);
+                  log16.debug(`list_pages: agent ${agentId2} sees ${filtered.length}/${parsed.length} pages (strict ownership filter)`);
                 }
                 return JSON.stringify(filtered);
               }
@@ -45509,7 +45955,7 @@ var init_browser_session = __esm({
             const targetId = this.extractTargetIdFromArgs(args);
             if (targetId && !this.isOwnedByMe(agentId2, targetId)) {
               const msg = `Cannot select page ${targetId}: you can only select pages you created with new_page. Use new_page to open your own tab.`;
-              log15.warn(msg, { agentId: agentId2, targetId });
+              log16.warn(msg, { agentId: agentId2, targetId });
               return JSON.stringify({ error: msg });
             }
             return handler4.execute(args);
@@ -45524,7 +45970,7 @@ var init_browser_session = __esm({
             const targetId = this.extractTargetIdFromArgs(args);
             if (targetId && !this.isOwnedByMe(agentId2, targetId)) {
               const msg = `Cannot close page ${targetId}: you can only close pages you created with new_page. Do not close tabs you did not open.`;
-              log15.warn(msg, { agentId: agentId2, targetId });
+              log16.warn(msg, { agentId: agentId2, targetId });
               return JSON.stringify({ error: msg });
             }
             const result = await handler4.execute(args);
@@ -45547,13 +45993,13 @@ var init_browser_session = __esm({
             const owned = this.getOwned(agentId2);
             if (owned.size === 0) {
               const msg = "You have no owned pages. Call new_page first to create your own tab before navigating.";
-              log15.warn(`Agent ${agentId2} called navigate_page with no owned pages`, { agentId: agentId2, url: args.url });
+              log16.warn(`Agent ${agentId2} called navigate_page with no owned pages`, { agentId: agentId2, url: args.url });
               return JSON.stringify({ error: msg });
             }
             const targetId = this.extractTargetIdFromArgs(args);
             if (targetId && !owned.has(targetId)) {
               const msg = `Cannot navigate page ${targetId}: it is not a page you own. Use new_page to create your own tab.`;
-              log15.warn(msg, { agentId: agentId2, targetId });
+              log16.warn(msg, { agentId: agentId2, targetId });
               return JSON.stringify({ error: msg });
             }
             return handler4.execute(args);
@@ -45577,13 +46023,13 @@ var init_browser_session = __esm({
             const owned = this.getOwned(agentId2);
             if (owned.size === 0) {
               const msg = `Cannot use ${toolName} before creating a tab. Call new_page first to create your own tab.`;
-              log15.warn(`Agent ${agentId2} called ${toolName} with no owned pages`, { agentId: agentId2 });
+              log16.warn(`Agent ${agentId2} called ${toolName} with no owned pages`, { agentId: agentId2 });
               return JSON.stringify({ error: msg });
             }
             const targetId = this.extractTargetIdFromArgs(args);
             if (targetId && !owned.has(targetId)) {
               const msg = `Cannot use ${toolName} on page ${targetId}: it is not a page you own. Only interact with pages you created via new_page.`;
-              log15.warn(msg, { agentId: agentId2, targetId, toolName });
+              log16.warn(msg, { agentId: agentId2, targetId, toolName });
               return JSON.stringify({ error: msg });
             }
             return handler4.execute(args);
@@ -45597,7 +46043,7 @@ var init_browser_session = __esm({
       cleanupAgent(agentId2) {
         const owned = this.ownedPages.get(agentId2);
         if (owned?.size) {
-          log15.info(`Cleaning up ${owned.size} browser page(s) for agent ${agentId2}`);
+          log16.info(`Cleaning up ${owned.size} browser page(s) for agent ${agentId2}`);
         }
         this.ownedPages.delete(agentId2);
       }
@@ -45647,7 +46093,7 @@ function createManagerTools(ctx) {
         const targetId = args["agent_id"];
         const message = args["message"];
         ctx.delegateMessage(targetId, message, "manager").catch((err) => {
-          log16.warn(`Delegated task to ${targetId} failed in background`, { error: String(err) });
+          log17.warn(`Delegated task to ${targetId} failed in background`, { error: String(err) });
         });
         return JSON.stringify({ status: "dispatched", message: "Task dispatched. The agent will work on it independently." });
       }
@@ -45726,12 +46172,12 @@ function createManagerTools(ctx) {
     ] : []
   ];
 }
-var log16;
+var log17;
 var init_manager = __esm({
   "../core/dist/tools/manager.js"() {
     "use strict";
     init_dist();
-    log16 = createLogger("manager-tools");
+    log17 = createLogger("manager-tools");
   }
 });
 
@@ -45771,19 +46217,19 @@ function createA2ATools(ctx) {
           return JSON.stringify({ status: "error", error: "Cannot send a message to yourself" });
         }
         if (waitForReply) {
-          log17.info(`A2A request (sync): ${ctx.selfName} \u2192 ${targetId}`, { messageLen: message.length });
+          log18.info(`A2A request (sync): ${ctx.selfName} \u2192 ${targetId}`, { messageLen: message.length });
           try {
             const reply = await ctx.sendMessage(targetId, message, ctx.selfId, ctx.selfName);
-            log17.info(`A2A reply received: ${targetId} \u2192 ${ctx.selfName}`, { replyLen: reply.length });
+            log18.info(`A2A reply received: ${targetId} \u2192 ${ctx.selfName}`, { replyLen: reply.length });
             return JSON.stringify({ status: "replied", from: targetId, reply });
           } catch (err) {
-            log17.warn(`A2A sync message to ${targetId} failed`, { error: String(err) });
+            log18.warn(`A2A sync message to ${targetId} failed`, { error: String(err) });
             return JSON.stringify({ status: "error", error: `Failed to get reply: ${String(err)}` });
           }
         }
-        log17.info(`A2A notify (async): ${ctx.selfName} \u2192 ${targetId}`, { messageLen: message.length });
+        log18.info(`A2A notify (async): ${ctx.selfName} \u2192 ${targetId}`, { messageLen: message.length });
         ctx.sendMessage(targetId, message, ctx.selfId, ctx.selfName).catch((err) => {
-          log17.warn(`A2A async message to ${targetId} failed in background`, { error: String(err) });
+          log18.warn(`A2A async message to ${targetId} failed in background`, { error: String(err) });
         });
         return JSON.stringify({ status: "dispatched", message: "Notification sent. The agent will process it independently." });
       }
@@ -45859,12 +46305,12 @@ function createA2ATools(ctx) {
     }] : []
   ];
 }
-var log17;
+var log18;
 var init_a2a = __esm({
   "../core/dist/tools/a2a.js"() {
     "use strict";
     init_dist();
-    log17 = createLogger("a2a-tools");
+    log18 = createLogger("a2a-tools");
   }
 });
 
@@ -45891,7 +46337,7 @@ function createStructuredA2ATools(ctx) {
       }
     };
     const message = JSON.stringify(structuredMessage);
-    log18.info(`Structured A2A message dispatched: ${ctx.selfName} \u2192 ${targetId}`, {
+    log19.info(`Structured A2A message dispatched: ${ctx.selfName} \u2192 ${targetId}`, {
       messageType,
       payloadSize: JSON.stringify(payload).length
     });
@@ -45899,7 +46345,7 @@ function createStructuredA2ATools(ctx) {
       try {
         await ctx.sendMessage(targetId, message, ctx.selfId, ctx.selfName);
       } catch (err) {
-        log18.warn(`Structured A2A message to ${targetId} failed in background`, {
+        log19.warn(`Structured A2A message to ${targetId} failed in background`, {
           error: String(err),
           messageType
         });
@@ -45993,12 +46439,12 @@ function createStructuredA2ATools(ctx) {
     }
   ];
 }
-var log18, A2A_SEND_INTERVAL_MS, sendQueue;
+var log19, A2A_SEND_INTERVAL_MS, sendQueue;
 var init_a2a_structured = __esm({
   "../core/dist/tools/a2a-structured.js"() {
     "use strict";
     init_dist();
-    log18 = createLogger("a2a-structured-tools");
+    log19 = createLogger("a2a-structured-tools");
     A2A_SEND_INTERVAL_MS = 3e4;
     sendQueue = Promise.resolve();
   }
@@ -46118,7 +46564,7 @@ function createAgentTaskTools(ctx) {
             taskType,
             scheduleConfig
           });
-          log19.info(`Task created by agent ${ctx.agentId}`, { taskId: task.id, title: task.title, assignedAgentId });
+          log20.info(`Task created by agent ${ctx.agentId}`, { taskId: task.id, title: task.title, assignedAgentId });
           if (task.status === "pending_approval") {
             return JSON.stringify({
               status: "pending_approval",
@@ -46132,7 +46578,7 @@ function createAgentTaskTools(ctx) {
             message: `Task created: "${task.title}" (ID: ${task.id})`
           });
         } catch (error) {
-          log19.error("task_create failed", { error: String(error) });
+          log20.error("task_create failed", { error: String(error) });
           return JSON.stringify({ status: "error", error: String(error) });
         }
       }
@@ -46302,7 +46748,7 @@ function createAgentTaskTools(ctx) {
                     await ctx.addTaskNote(task2.id, note, ctx.agentName).catch(() => {
                     });
                   }
-                  log19.info(`Pending task cancelled by creator ${ctx.agentId}`, { taskId: task2.id });
+                  log20.info(`Pending task cancelled by creator ${ctx.agentId}`, { taskId: task2.id });
                   return JSON.stringify({
                     status: "success",
                     task: task2,
@@ -46315,7 +46761,7 @@ function createAgentTaskTools(ctx) {
                 });
               }
               if (existing?.assignedAgentId === ctx.agentId && existing?.status === "in_progress") {
-                log19.warn(`Agent ${ctx.agentId} attempted to set own running task to "${newStatus}"`, { taskId: taskId2 });
+                log20.warn(`Agent ${ctx.agentId} attempted to set own running task to "${newStatus}"`, { taskId: taskId2 });
                 return JSON.stringify({
                   status: "denied",
                   error: `Setting your own running task to "${newStatus}" will immediately abort all ongoing work. If you truly need to stop, confirm by adding a note explaining why. Otherwise, continue working on the task.`
@@ -46335,7 +46781,7 @@ function createAgentTaskTools(ctx) {
               await ctx.addTaskNote(task.id, note, ctx.agentName).catch(() => {
               });
             }
-            log19.info(`Task updated by agent ${ctx.agentId}`, {
+            log20.info(`Task updated by agent ${ctx.agentId}`, {
               taskId: task.id,
               status: task.status
             });
@@ -46352,7 +46798,7 @@ function createAgentTaskTools(ctx) {
               await ctx.addTaskNote(taskId2, note, ctx.agentName);
             }
             const task = ctx.getTask ? await ctx.getTask(taskId2) : null;
-            log19.info(`Task updated by agent ${ctx.agentId}`, { taskId: taskId2, hasNote: !!note, hasDescription: description !== void 0, hasBlockedBy: blockedBy !== void 0 });
+            log20.info(`Task updated by agent ${ctx.agentId}`, { taskId: taskId2, hasNote: !!note, hasDescription: description !== void 0, hasBlockedBy: blockedBy !== void 0 });
             return JSON.stringify({
               status: "success",
               task,
@@ -46646,7 +47092,7 @@ function createAgentTaskTools(ctx) {
               projectId: args["project_id"],
               tags: args["tags"]
             });
-            log19.info(`Requirement proposed by agent ${ctx.agentId}`, {
+            log20.info(`Requirement proposed by agent ${ctx.agentId}`, {
               requirementId: req.id,
               title: req.title
             });
@@ -46656,7 +47102,7 @@ function createAgentTaskTools(ctx) {
               message: `Requirement proposed: "${req.title}" (ID: ${req.id}). It will be reviewed by a human user. Do NOT create tasks for this until it is approved.`
             });
           } catch (error) {
-            log19.error("requirement_propose failed", { error: String(error) });
+            log20.error("requirement_propose failed", { error: String(error) });
             return JSON.stringify({ status: "error", error: String(error) });
           }
         }
@@ -46749,7 +47195,7 @@ function createAgentTaskTools(ctx) {
         async execute(args) {
           try {
             const req = await ctx.updateRequirementStatus(args["requirement_id"], args["status"], args["reason"]);
-            log19.info(`Requirement status updated by agent ${ctx.agentId}`, {
+            log20.info(`Requirement status updated by agent ${ctx.agentId}`, {
               requirementId: req.id,
               newStatus: req.status,
               reason: args["reason"]
@@ -46760,7 +47206,7 @@ function createAgentTaskTools(ctx) {
               message: `Requirement "${req.title}" (ID: ${req.id}) status changed to ${req.status}.`
             });
           } catch (error) {
-            log19.error("requirement_update_status failed", { error: String(error) });
+            log20.error("requirement_update_status failed", { error: String(error) });
             return JSON.stringify({ status: "error", error: String(error) });
           }
         }
@@ -46768,12 +47214,12 @@ function createAgentTaskTools(ctx) {
     ] : []
   ];
 }
-var log19;
+var log20;
 var init_task_tools = __esm({
   "../core/dist/tools/task-tools.js"() {
     "use strict";
     init_dist();
-    log19 = createLogger("task-tools");
+    log20 = createLogger("task-tools");
   }
 });
 
@@ -47100,10 +47546,10 @@ function createMemoryTools(ctx) {
         ctx.memory.addEntry(entry);
         if (ctx.semanticSearch?.isEnabled()) {
           ctx.semanticSearch.indexMemory(entry, ctx.agentId).catch((err) => {
-            log20.warn("Failed to index memory for semantic search", { error: String(err) });
+            log21.warn("Failed to index memory for semantic search", { error: String(err) });
           });
         }
-        log20.info("Agent saved memory", { agentId: ctx.agentId, type, contentLen: content.length });
+        log21.info("Agent saved memory", { agentId: ctx.agentId, type, contentLen: content.length });
         return JSON.stringify({ status: "saved", id: entry.id, type });
       }
     },
@@ -47142,7 +47588,7 @@ function createMemoryTools(ctx) {
             let entries2 = semResults.map((r) => r.entry);
             if (type)
               entries2 = entries2.filter((e) => e.type === type);
-            log20.debug("Semantic memory search", { agentId: ctx.agentId, query: query2, results: entries2.length });
+            log21.debug("Semantic memory search", { agentId: ctx.agentId, query: query2, results: entries2.length });
             return JSON.stringify({
               results: entries2.map((e) => ({
                 id: e.id,
@@ -47154,14 +47600,14 @@ function createMemoryTools(ctx) {
               count: entries2.length
             });
           } catch (err) {
-            log20.warn("Semantic search failed, falling back to substring", { error: String(err) });
+            log21.warn("Semantic search failed, falling back to substring", { error: String(err) });
           }
         }
         let results = ctx.memory.search(query2);
         if (type)
           results = results.filter((e) => e.type === type);
         results = results.slice(0, limit);
-        log20.debug("Memory search (substring)", { agentId: ctx.agentId, query: query2, results: results.length });
+        log21.debug("Memory search (substring)", { agentId: ctx.agentId, query: query2, results: results.length });
         return JSON.stringify({
           results: results.map((e) => ({
             id: e.id,
@@ -47227,18 +47673,18 @@ function createMemoryTools(ctx) {
         const section = args["section"];
         const content = args["content"];
         ctx.memory.addLongTermMemory(section, content);
-        log20.info("Agent updated long-term memory", { agentId: ctx.agentId, section, contentLen: content.length });
+        log21.info("Agent updated long-term memory", { agentId: ctx.agentId, section, contentLen: content.length });
         return JSON.stringify({ status: "updated", section });
       }
     }
   ];
 }
-var log20;
+var log21;
 var init_memory = __esm({
   "../core/dist/tools/memory.js"() {
     "use strict";
     init_dist();
-    log20 = createLogger("memory-tools");
+    log21 = createLogger("memory-tools");
   }
 });
 
@@ -47257,12 +47703,12 @@ function cosineSimilarity(a, b) {
   const denom = Math.sqrt(normA) * Math.sqrt(normB);
   return denom === 0 ? 0 : dot / denom;
 }
-var log21, OpenAIEmbeddingProvider, PgVectorStore, LocalVectorStore, SemanticMemorySearch;
+var log22, OpenAIEmbeddingProvider, PgVectorStore, LocalVectorStore, SemanticMemorySearch;
 var init_semantic_search = __esm({
   "../core/dist/memory/semantic-search.js"() {
     "use strict";
     init_dist();
-    log21 = createLogger("semantic-search");
+    log22 = createLogger("semantic-search");
     OpenAIEmbeddingProvider = class {
       dimensions;
       apiKey;
@@ -47316,7 +47762,7 @@ var init_semantic_search = __esm({
             params: [id, metadata.agentId, metadata.content, metadata.type, vectorStr]
           });
         } catch (err) {
-          log21.warn("Vector upsert failed, pgvector may not be available", { error: String(err) });
+          log22.warn("Vector upsert failed, pgvector may not be available", { error: String(err) });
         }
       }
       async search(queryEmbedding, opts) {
@@ -47340,7 +47786,7 @@ var init_semantic_search = __esm({
             type: r["type"]
           }));
         } catch (err) {
-          log21.warn("Vector search failed", { error: String(err) });
+          log22.warn("Vector search failed", { error: String(err) });
           return [];
         }
       }
@@ -47372,10 +47818,10 @@ var init_semantic_search = __esm({
             params: []
           });
           this.pgvectorAvailable = true;
-          log21.info("pgvector memory_embeddings table ready");
+          log22.info("pgvector memory_embeddings table ready");
           return true;
         } catch (err) {
-          log21.warn("pgvector setup failed, semantic search will use fallback", { error: String(err) });
+          log22.warn("pgvector setup failed, semantic search will use fallback", { error: String(err) });
           this.pgvectorAvailable = false;
           return false;
         }
@@ -47424,10 +47870,10 @@ var init_semantic_search = __esm({
           if (existsSync14(this.storePath)) {
             const data = JSON.parse(readFileSync11(this.storePath, "utf-8"));
             this.vectors = new Map(data);
-            log21.info("Local vector store loaded", { entries: this.vectors.size });
+            log22.info("Local vector store loaded", { entries: this.vectors.size });
           }
         } catch (err) {
-          log21.warn("Failed to load local vector store", { error: String(err) });
+          log22.warn("Failed to load local vector store", { error: String(err) });
         }
       }
       scheduleSave() {
@@ -47442,7 +47888,7 @@ var init_semantic_search = __esm({
             writeFileSync8(this.storePath, JSON.stringify(Array.from(this.vectors.entries())));
             this.dirty = false;
           } catch (err) {
-            log21.warn("Failed to save local vector store", { error: String(err) });
+            log22.warn("Failed to save local vector store", { error: String(err) });
           }
         }, 2e3);
       }
@@ -47477,7 +47923,7 @@ var init_semantic_search = __esm({
             type: entry.type
           });
         } catch (err) {
-          log21.warn("Failed to index memory entry", { id: entry.id, error: String(err) });
+          log22.warn("Failed to index memory entry", { id: entry.id, error: String(err) });
         }
       }
       async search(query2, opts) {
@@ -47500,7 +47946,7 @@ var init_semantic_search = __esm({
             similarity: r.similarity
           }));
         } catch (err) {
-          log21.warn("Semantic search failed, returning empty results", { error: String(err) });
+          log22.warn("Semantic search failed, returning empty results", { error: String(err) });
           return [];
         }
       }
@@ -47514,12 +47960,12 @@ var init_semantic_search = __esm({
 });
 
 // ../a2a/dist/bus.js
-var log22, MAX_RETRIES, RETRY_BASE_MS, A2ABus;
+var log23, MAX_RETRIES, RETRY_BASE_MS, A2ABus;
 var init_bus = __esm({
   "../a2a/dist/bus.js"() {
     "use strict";
     init_dist();
-    log22 = createLogger("a2a-bus");
+    log23 = createLogger("a2a-bus");
     MAX_RETRIES = 3;
     RETRY_BASE_MS = 1e3;
     A2ABus = class {
@@ -47527,11 +47973,11 @@ var init_bus = __esm({
       agentEndpoints = /* @__PURE__ */ new Map();
       registerAgent(agentId2, handler4) {
         this.agentEndpoints.set(agentId2, handler4);
-        log22.info(`Agent registered on A2A bus: ${agentId2}`);
+        log23.info(`Agent registered on A2A bus: ${agentId2}`);
       }
       unregisterAgent(agentId2) {
         this.agentEndpoints.delete(agentId2);
-        log22.info(`Agent unregistered from A2A bus: ${agentId2}`);
+        log23.info(`Agent unregistered from A2A bus: ${agentId2}`);
       }
       on(type, handler4) {
         const existing = this.handlers.get(type) ?? [];
@@ -47548,7 +47994,7 @@ var init_bus = __esm({
             lastError = error;
             if (attempt < MAX_RETRIES - 1) {
               const delay = RETRY_BASE_MS * Math.pow(2, attempt);
-              log22.warn(`${label} failed, retrying (${attempt + 1}/${MAX_RETRIES})`, {
+              log23.warn(`${label} failed, retrying (${attempt + 1}/${MAX_RETRIES})`, {
                 error: String(error).slice(0, 200),
                 delay
               });
@@ -47556,10 +48002,10 @@ var init_bus = __esm({
             }
           }
         }
-        log22.error(`${label} failed after ${MAX_RETRIES} retries`, { error: String(lastError) });
+        log23.error(`${label} failed after ${MAX_RETRIES} retries`, { error: String(lastError) });
       }
       async send(envelope) {
-        log22.debug(`A2A message: ${envelope.type} from=${envelope.from} to=${envelope.to}`, {
+        log23.debug(`A2A message: ${envelope.type} from=${envelope.from} to=${envelope.to}`, {
           id: envelope.id,
           correlationId: envelope.correlationId
         });
@@ -47567,7 +48013,7 @@ var init_bus = __esm({
         if (agentHandler) {
           await this.deliverWithRetry(agentHandler, envelope, `A2A delivery to ${envelope.to}`);
         } else {
-          log22.warn(`A2A target agent not found: ${envelope.to}`);
+          log23.warn(`A2A target agent not found: ${envelope.to}`);
         }
         const typeHandlers = this.handlers.get(envelope.type) ?? [];
         for (const handler4 of typeHandlers) {
@@ -47596,12 +48042,12 @@ var init_bus = __esm({
 });
 
 // ../a2a/dist/delegation.js
-var log23, DelegationManager;
+var log24, DelegationManager;
 var init_delegation = __esm({
   "../a2a/dist/delegation.js"() {
     "use strict";
     init_dist();
-    log23 = createLogger("a2a-delegation");
+    log24 = createLogger("a2a-delegation");
     DelegationManager = class {
       bus;
       agentCards = /* @__PURE__ */ new Map();
@@ -47661,7 +48107,7 @@ var init_delegation = __esm({
           payload: delegation
         };
         await this.bus.send(envelope);
-        log23.info(`Task delegated from ${fromAgentId} to ${targetId}`, {
+        log24.info(`Task delegated from ${fromAgentId} to ${targetId}`, {
           taskId: delegation.taskId,
           title: delegation.title
         });
@@ -47700,7 +48146,7 @@ var init_delegation = __esm({
       }
       async handleDelegation(envelope) {
         const delegation = envelope.payload;
-        log23.info(`Received task delegation: ${delegation.title}`, {
+        log24.info(`Received task delegation: ${delegation.title}`, {
           from: envelope.from,
           to: envelope.to,
           taskId: delegation.taskId
@@ -47711,14 +48157,14 @@ var init_delegation = __esm({
       }
       async handleUpdate(envelope) {
         const update2 = envelope.payload;
-        log23.info(`Task update: ${update2.taskId} -> ${update2.status}`, {
+        log24.info(`Task update: ${update2.taskId} -> ${update2.status}`, {
           from: envelope.from,
           progress: update2.progress
         });
       }
       async handleComplete(envelope) {
         const update2 = envelope.payload;
-        log23.info(`Task completed: ${update2.taskId}`, {
+        log24.info(`Task completed: ${update2.taskId}`, {
           from: envelope.from,
           to: envelope.to
         });
@@ -47728,22 +48174,22 @@ var init_delegation = __esm({
 });
 
 // ../a2a/dist/collaboration.js
-var log24;
+var log25;
 var init_collaboration = __esm({
   "../a2a/dist/collaboration.js"() {
     "use strict";
     init_dist();
-    log24 = createLogger("a2a-collaboration");
+    log25 = createLogger("a2a-collaboration");
   }
 });
 
 // ../a2a/dist/structured.js
-var log25;
+var log26;
 var init_structured = __esm({
   "../a2a/dist/structured.js"() {
     "use strict";
     init_dist();
-    log25 = createLogger("a2a-structured");
+    log26 = createLogger("a2a-structured");
   }
 });
 
@@ -47771,7 +48217,7 @@ function resolveCurrentTaskId(agentObj, ts, agentId2) {
     const currentTask = ts.getTask(currentId);
     if (currentTask?.status === "in_progress")
       return currentId;
-    log26.warn("Agent currentTaskId is no longer in_progress, searching activeTasks for a valid candidate", {
+    log27.warn("Agent currentTaskId is no longer in_progress, searching activeTasks for a valid candidate", {
       agentId: agentId2,
       currentTaskId: currentId,
       actualStatus: currentTask?.status
@@ -47785,13 +48231,13 @@ function resolveCurrentTaskId(agentObj, ts, agentId2) {
   for (const t of activeTasks) {
     const task = ts.getTask(t.taskId);
     if (task && ["completed", "failed", "cancelled", "archived"].includes(task.status)) {
-      log26.warn("Removing stale task from agent activeTasks", { agentId: agentId2, taskId: t.taskId, status: task.status });
+      log27.warn("Removing stale task from agent activeTasks", { agentId: agentId2, taskId: t.taskId, status: task.status });
       agentObj?.removeActiveTask(t.taskId);
     }
   }
   throw new Error(`No in_progress task found for agent ${agentId2} \u2014 cannot submit for review. Active task IDs: [${activeTasks.map((t) => t.taskId).join(", ")}]`);
 }
-var log26, AgentManager;
+var log27, AgentManager;
 var init_agent_manager = __esm({
   "../core/dist/agent-manager.js"() {
     "use strict";
@@ -47811,7 +48257,7 @@ var init_agent_manager = __esm({
     init_semantic_search();
     init_security();
     init_dist3();
-    log26 = createLogger("agent-manager");
+    log27 = createLogger("agent-manager");
     AgentManager = class _AgentManager {
       agents = /* @__PURE__ */ new Map();
       eventBus;
@@ -47840,6 +48286,7 @@ var init_agent_manager = __esm({
       activityCallbacks;
       a2aBus;
       delegationManager;
+      _maxToolIterations = 200;
       templateRegistry;
       groupChatHandlers;
       buildKnowledgeCallbacks(agentId2, orgId2) {
@@ -47954,11 +48401,11 @@ var init_agent_manager = __esm({
           this.semanticSearch = new SemanticMemorySearch(embeddingProvider, vectorStore);
           this.semanticSearch.initialize().then((ok) => {
             if (ok)
-              log26.info("Semantic memory search initialized (LocalVectorStore)");
+              log27.info("Semantic memory search initialized (LocalVectorStore)");
             else
-              log26.warn("Semantic memory search initialization failed");
+              log27.warn("Semantic memory search initialization failed");
           }).catch((err) => {
-            log26.warn("Semantic memory search init error", { error: String(err) });
+            log27.warn("Semantic memory search init error", { error: String(err) });
           });
         }
         this.a2aBus = new A2ABus();
@@ -47966,7 +48413,7 @@ var init_agent_manager = __esm({
         this.delegationManager.onDelegationReceived(async (envelope, delegation) => {
           const targetAgent = this.agents.get(envelope.to);
           if (!targetAgent) {
-            log26.warn("Delegation target agent not found", { to: envelope.to });
+            log27.warn("Delegation target agent not found", { to: envelope.to });
             return;
           }
           if (this.taskService) {
@@ -47980,7 +48427,7 @@ var init_agent_manager = __esm({
               createdBy: envelope.from,
               creatorRole: "manager"
             });
-            log26.info("Delegation created real task", {
+            log27.info("Delegation created real task", {
               taskId: task.id,
               delegatedTo: envelope.to,
               from: envelope.from,
@@ -47996,6 +48443,12 @@ Priority: ${delegation.priority}`, envelope.from, { name: envelope.from, role: "
         this.templateRegistry = options.templateRegistry;
         mkdirSync9(this.dataDir, { recursive: true });
       }
+      get maxToolIterations() {
+        return this._maxToolIterations;
+      }
+      set maxToolIterations(value) {
+        this._maxToolIterations = Math.max(1, Math.min(value, 1e4));
+      }
       setTaskService(taskService) {
         this.taskService = taskService;
       }
@@ -48117,7 +48570,8 @@ Priority: ${delegation.priority}`, envelope.from, { name: envelope.from, role: "
           tools,
           orgContext: request.orgContext,
           pathPolicy,
-          skillRegistry: this.skillRegistry
+          skillRegistry: this.skillRegistry,
+          maxToolIterations: this._maxToolIterations
         };
         const agent = new Agent(agentOpts);
         if (this.skillRegistry) {
@@ -48126,14 +48580,14 @@ Priority: ${delegation.priority}`, envelope.from, { name: envelope.from, role: "
             agent.injectSkillInstructions(skillName, instructions);
           }
           if (builtinInstructions.size > 0) {
-            log26.info(`Always-on builtin skills injected for agent ${id}`, { skills: [...builtinInstructions.keys()] });
+            log27.info(`Always-on builtin skills injected for agent ${id}`, { skills: [...builtinInstructions.keys()] });
           }
           agent.setAvailableSkillCatalog(this.skillRegistry.getBuiltinSkillCatalog());
         }
         if (this.skillRegistry && config.skills.length > 0) {
           const missingSkills = config.skills.filter((s) => !this.skillRegistry.get(s));
           if (missingSkills.length > 0) {
-            log26.warn(`Agent ${config.name} (${id}) references skills not found in registry`, {
+            log27.warn(`Agent ${config.name} (${id}) references skills not found in registry`, {
               missing: missingSkills,
               available: this.skillRegistry.list().map((s) => s.name)
             });
@@ -48165,12 +48619,12 @@ Priority: ${delegation.priority}`, envelope.from, { name: envelope.from, role: "
                     toolNames.push(tool.name);
                   }
                   agent.activateTools(toolNames);
-                  log26.info(`Skill ${skillName} MCP server ${serverName} connected for agent ${id}`, {
+                  log27.info(`Skill ${skillName} MCP server ${serverName} connected for agent ${id}`, {
                     toolCount: mcpTools.length,
                     isolated
                   });
                 } catch (error) {
-                  log26.warn(`Failed to connect skill ${skillName} MCP server ${serverName} for agent ${id}`, {
+                  log27.warn(`Failed to connect skill ${skillName} MCP server ${serverName} for agent ${id}`, {
                     error: String(error)
                   });
                 }
@@ -48401,7 +48855,7 @@ Known issues: ${knownIssues}` : ""}`
               return [];
             }
           });
-          log26.info(`Task tools injected for agent ${id}`);
+          log27.info(`Task tools injected for agent ${id}`);
         }
         if (this.projectService) {
           for (const tool of createProjectTools({
@@ -48415,8 +48869,10 @@ Known issues: ${knownIssues}` : ""}`
           }
         }
         if (request.agentRole === "manager") {
+          const myTeamId = config.teamId;
+          const filterByTeam = (list2) => myTeamId ? list2.filter((a) => a.teamId === myTeamId) : list2;
           const managerTools = createManagerTools({
-            listAgents: () => this.listAgents().map((a) => {
+            listAgents: () => filterByTeam(this.listAgents()).map((a) => {
               try {
                 const ag = this.getAgent(a.id);
                 return { ...a, skills: ag.config.skills };
@@ -48429,7 +48885,7 @@ Known issues: ${knownIssues}` : ""}`
               const reply = await target.handleMessage(message, id, { name: config.name, role: "manager" });
               return stripInternalBlocks(reply);
             },
-            getTeamStatus: () => this.listAgents().map((a) => {
+            getTeamStatus: () => filterByTeam(this.listAgents()).map((a) => {
               try {
                 const ag = this.getAgent(a.id);
                 const state = ag.getState();
@@ -48459,11 +48915,11 @@ Known issues: ${knownIssues}` : ""}`
               for (const tool of mcpTools) {
                 agent.registerTool(tool);
               }
-              log26.info(`MCP server ${serverName} tools registered for agent ${id}`, {
+              log27.info(`MCP server ${serverName} tools registered for agent ${id}`, {
                 toolCount: mcpTools.length
               });
             } catch (error) {
-              log26.warn(`Failed to connect MCP server ${serverName} for agent ${id}`, {
+              log27.warn(`Failed to connect MCP server ${serverName} for agent ${id}`, {
                 error: String(error)
               });
             }
@@ -48499,7 +48955,7 @@ Known issues: ${knownIssues}` : ""}`
           status: "idle"
         });
         this.eventBus.emit("agent:created", { agentId: id, name: request.name });
-        log26.info(`Agent created: ${request.name} (${id})`);
+        log27.info(`Agent created: ${request.name} (${id})`);
         return agent;
       }
       /**
@@ -48604,7 +49060,8 @@ Known issues: ${knownIssues}` : ""}`
           tools,
           pathPolicy,
           restoredState: { tokensUsedToday: row.tokensUsedToday ?? 0 },
-          skillRegistry: this.skillRegistry
+          skillRegistry: this.skillRegistry,
+          maxToolIterations: this._maxToolIterations
         });
         if (this.skillRegistry) {
           const builtinInstructions = this.skillRegistry.getBuiltinInstructions();
@@ -48616,7 +49073,7 @@ Known issues: ${knownIssues}` : ""}`
         if (this.skillRegistry && config.skills.length > 0) {
           const missingSkills = config.skills.filter((s) => !this.skillRegistry.get(s));
           if (missingSkills.length > 0) {
-            log26.warn(`Restored agent ${config.name} (${id}) references skills not found in registry`, {
+            log27.warn(`Restored agent ${config.name} (${id}) references skills not found in registry`, {
               missing: missingSkills,
               available: this.skillRegistry.list().map((s) => s.name)
             });
@@ -48648,12 +49105,12 @@ Known issues: ${knownIssues}` : ""}`
                     toolNames.push(tool.name);
                   }
                   agent.activateTools(toolNames);
-                  log26.info(`Skill ${skillName} MCP server ${serverName} restored for agent ${id}`, {
+                  log27.info(`Skill ${skillName} MCP server ${serverName} restored for agent ${id}`, {
                     toolCount: mcpTools.length,
                     isolated
                   });
                 } catch (error) {
-                  log26.warn(`Failed to restore skill ${skillName} MCP server ${serverName} for agent ${id}`, {
+                  log27.warn(`Failed to restore skill ${skillName} MCP server ${serverName} for agent ${id}`, {
                     error: String(error)
                   });
                 }
@@ -48866,8 +49323,10 @@ Known issues: ${knownIssues}` : ""}`
           }
         }
         if (config.agentRole === "manager") {
+          const restoredTeamId = config.teamId;
+          const filterByTeamRestored = (list2) => restoredTeamId ? list2.filter((a) => a.teamId === restoredTeamId) : list2;
           const managerTools = createManagerTools({
-            listAgents: () => this.listAgents().map((a) => {
+            listAgents: () => filterByTeamRestored(this.listAgents()).map((a) => {
               try {
                 const ag = this.getAgent(a.id);
                 return { ...a, skills: ag.config.skills };
@@ -48880,7 +49339,7 @@ Known issues: ${knownIssues}` : ""}`
               const reply = await target.handleMessage(message, id, { name: config.name, role: "manager" });
               return stripInternalBlocks(reply);
             },
-            getTeamStatus: () => this.listAgents().map((a) => {
+            getTeamStatus: () => filterByTeamRestored(this.listAgents()).map((a) => {
               try {
                 const ag = this.getAgent(a.id);
                 const state = ag.getState();
@@ -48930,7 +49389,7 @@ Known issues: ${knownIssues}` : ""}`
           status: "idle"
         });
         this.eventBus.emit("agent:created", { agentId: id, name: row.name });
-        log26.info(`Agent restored: ${row.name} (${id})`, {
+        log27.info(`Agent restored: ${row.name} (${id})`, {
           profile: config.profile ? "yes" : "no",
           tokensUsedToday: row.tokensUsedToday ?? 0,
           activeTaskIds: Array.isArray(row.activeTaskIds) ? row.activeTaskIds.length : 0
@@ -48951,21 +49410,21 @@ Known issues: ${knownIssues}` : ""}`
           try {
             const task = this.taskService.getTask(taskId2);
             if (!task) {
-              log26.warn("Task not found during rehydration, skipping", { agentId: agentId2, taskId: taskId2 });
+              log27.warn("Task not found during rehydration, skipping", { agentId: agentId2, taskId: taskId2 });
               continue;
             }
             if (task.status === "completed" || task.status === "cancelled" || task.status === "failed") {
-              log26.debug("Task already terminal, skipping rehydration", {
+              log27.debug("Task already terminal, skipping rehydration", {
                 agentId: agentId2,
                 taskId: taskId2,
                 status: task.status
               });
               continue;
             }
-            log26.info("Re-queuing interrupted task", { agentId: agentId2, taskId: taskId2, title: task.title });
+            log27.info("Re-queuing interrupted task", { agentId: agentId2, taskId: taskId2, title: task.title });
             this.taskService.assignTask(taskId2, agentId2);
           } catch (error) {
-            log26.warn("Failed to rehydrate task", { agentId: agentId2, taskId: taskId2, error: String(error) });
+            log27.warn("Failed to rehydrate task", { agentId: agentId2, taskId: taskId2, error: String(error) });
           }
         }
       }
@@ -48996,13 +49455,13 @@ Known issues: ${knownIssues}` : ""}`
           if (existsSync15(agentDir)) {
             try {
               rmSync(agentDir, { recursive: true, force: true });
-              log26.info(`Agent data directory purged: ${agentDir}`);
+              log27.info(`Agent data directory purged: ${agentDir}`);
             } catch (err) {
-              log26.warn("Failed to purge agent data directory", { agentId: agentId2, error: String(err) });
+              log27.warn("Failed to purge agent data directory", { agentId: agentId2, error: String(err) });
             }
           }
         }
-        log26.info(`Agent removed: ${agentId2}`, { purgeFiles: !!opts?.purgeFiles });
+        log27.info(`Agent removed: ${agentId2}`, { purgeFiles: !!opts?.purgeFiles });
       }
       /** Remove orphaned agent directories that have no matching DB record */
       purgeOrphanedAgentDirs(knownAgentIds) {
@@ -49024,7 +49483,7 @@ Known issues: ${knownIssues}` : ""}`
           }
         }
         if (removed.length > 0)
-          log26.info(`Purged ${removed.length} orphaned agent directories`);
+          log27.info(`Purged ${removed.length} orphaned agent directories`);
         return { removed, failed };
       }
       getAgent(agentId2) {
@@ -49045,7 +49504,7 @@ Known issues: ${knownIssues}` : ""}`
           return;
         const reviewer = this.getAgent(reviewerAgentId);
         reviewer.grantReadOnlyAccess(worktreePath);
-        log26.info("Granted reviewer access to worktree", { reviewerAgentId, worktreePath });
+        log27.info("Granted reviewer access to worktree", { reviewerAgentId, worktreePath });
       }
       /**
        * Revoke a reviewer agent's read-only access to a task's worktree.
@@ -49056,7 +49515,7 @@ Known issues: ${knownIssues}` : ""}`
           return;
         const reviewer = this.getAgent(reviewerAgentId);
         reviewer.revokeReadOnlyAccess(worktreePath);
-        log26.info("Revoked reviewer access to worktree", { reviewerAgentId, worktreePath });
+        log27.info("Revoked reviewer access to worktree", { reviewerAgentId, worktreePath });
       }
       setAuditCallback(cb) {
         this.agentAuditCallback = cb;
@@ -49219,7 +49678,7 @@ Known issues: ${knownIssues}` : ""}`
         }
         this.globalPaused = true;
         this.eventBus.emit("system:pause-all", { reason });
-        log26.info("All agents paused", { reason });
+        log27.info("All agents paused", { reason });
       }
       async resumeAllAgents() {
         for (const [, agent] of this.agents) {
@@ -49230,7 +49689,7 @@ Known issues: ${knownIssues}` : ""}`
         this.globalPaused = false;
         this.emergencyMode = false;
         this.eventBus.emit("system:resume-all", {});
-        log26.info("All agents resumed");
+        log27.info("All agents resumed");
       }
       async emergencyStop() {
         for (const [, agent] of this.agents) {
@@ -49240,7 +49699,7 @@ Known issues: ${knownIssues}` : ""}`
         this.emergencyMode = true;
         this.globalPaused = true;
         this.eventBus.emit("system:emergency-stop", {});
-        log26.warn("EMERGENCY STOP \u2014 all agents stopped");
+        log27.warn("EMERGENCY STOP \u2014 all agents stopped");
       }
       isGlobalPaused() {
         return this.globalPaused;
@@ -49251,7 +49710,7 @@ Known issues: ${knownIssues}` : ""}`
       clearEmergencyMode() {
         this.emergencyMode = false;
         this.globalPaused = false;
-        log26.info("Emergency mode cleared");
+        log27.info("Emergency mode cleared");
       }
       async shutdown() {
         for (const [, agent] of this.agents) {
@@ -49260,7 +49719,7 @@ Known issues: ${knownIssues}` : ""}`
           } catch {
           }
         }
-        log26.info("AgentManager shutdown complete \u2014 all metrics flushed");
+        log27.info("AgentManager shutdown complete \u2014 all metrics flushed");
       }
       // ─── Role Template Versioning & Sync ──────────────────────────────────────
       static ROLE_FILES = ["ROLE.md", "HEARTBEAT.md", "POLICIES.md", "CONTEXT.md"];
@@ -49351,7 +49810,7 @@ Known issues: ${knownIssues}` : ""}`
           }
         }
         agent.reloadRole();
-        log26.info("Synced agent role from template", { agentId: agentId2, roleId, synced });
+        log27.info("Synced agent role from template", { agentId: agentId2, roleId, synced });
         return { agentId: agentId2, success: true, synced };
       }
       checkAllRoleUpdates() {
@@ -49381,7 +49840,7 @@ Known issues: ${knownIssues}` : ""}`
           }
         }
         this.eventBus.emit("system:announcement", announcement);
-        log26.info("Announcement broadcast", { id: announcement.id, title: announcement.title });
+        log27.info("Announcement broadcast", { id: announcement.id, title: announcement.title });
       }
       getActiveAnnouncements() {
         const now2 = (/* @__PURE__ */ new Date()).toISOString();
@@ -49395,13 +49854,20 @@ Known issues: ${knownIssues}` : ""}`
       }
       /**
        * Rebuild and inject identity context for all agents in an organization.
-       * Should be called after agents are added/removed or humans join/leave.
+       * Colleagues are scoped to the agent's own team; other teams are listed for cross-team awareness.
        */
-      refreshIdentityContexts(orgId2, orgName, humans) {
+      refreshIdentityContexts(orgId2, orgName, humans, teams2) {
         const orgAgents = [...this.agents.values()].filter((a) => a.config.orgId === orgId2);
-        const managerAgent = orgAgents.find((a) => a.config.agentRole === "manager");
+        const agentTeamMap = /* @__PURE__ */ new Map();
+        for (const t of teams2 ?? []) {
+          for (const aid of t.memberAgentIds)
+            agentTeamMap.set(aid, t.id);
+        }
         for (const agent of orgAgents) {
-          const colleagues = orgAgents.filter((a) => a.id !== agent.id).map((a) => ({
+          const myTeamId = agent.config.teamId ?? agentTeamMap.get(agent.id);
+          const myTeam = teams2?.find((t) => t.id === myTeamId);
+          const sameTeamAgents = myTeamId ? orgAgents.filter((a) => a.id !== agent.id && (a.config.teamId === myTeamId || agentTeamMap.get(a.id) === myTeamId)) : orgAgents.filter((a) => a.id !== agent.id);
+          const colleagues = sameTeamAgents.map((a) => ({
             id: a.id,
             name: a.config.name,
             role: a.role.name,
@@ -49409,6 +49875,19 @@ Known issues: ${knownIssues}` : ""}`
             skills: a.config.skills,
             status: a.getState().status
           }));
+          const teamManager = sameTeamAgents.find((a) => a.config.agentRole === "manager");
+          const otherTeams = (teams2 ?? []).filter((t) => t.id !== myTeamId).map((t) => ({
+            id: t.id,
+            name: t.name,
+            members: t.memberAgentIds.map((aid) => {
+              try {
+                const a = this.getAgent(aid);
+                return { id: a.id, name: a.config.name, role: a.role.name };
+              } catch {
+                return null;
+              }
+            }).filter((m) => m !== null)
+          })).filter((t) => t.members.length > 0);
           const identity = {
             self: {
               id: agent.id,
@@ -49418,13 +49897,15 @@ Known issues: ${knownIssues}` : ""}`
               skills: agent.config.skills
             },
             organization: { id: orgId2, name: orgName },
+            team: myTeam ? { id: myTeam.id, name: myTeam.name, description: myTeam.description } : void 0,
             colleagues,
+            otherTeams: otherTeams.length > 0 ? otherTeams : void 0,
             humans: humans.map((h) => ({ id: h.id, name: h.name, role: h.role })),
-            manager: managerAgent && managerAgent.id !== agent.id ? { id: managerAgent.id, name: managerAgent.config.name } : void 0
+            manager: teamManager && teamManager.id !== agent.id ? { id: teamManager.id, name: teamManager.config.name } : void 0
           };
           agent.setIdentityContext(identity);
         }
-        log26.info(`Refreshed identity contexts for ${orgAgents.length} agents in org ${orgId2}`);
+        log27.info(`Refreshed identity contexts for ${orgAgents.length} agents in org ${orgId2}`);
       }
     };
   }
@@ -50484,12 +50965,12 @@ var init_ollama = __esm({
 import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10, existsSync as existsSync16, unlinkSync as unlinkSync2 } from "node:fs";
 import { join as join10 } from "node:path";
 import { homedir as homedir5 } from "node:os";
-var log27, AuthProfileStore;
+var log28, AuthProfileStore;
 var init_auth_profiles = __esm({
   "../core/dist/llm/auth-profiles.js"() {
     "use strict";
     init_dist();
-    log27 = createLogger("auth-profiles");
+    log28 = createLogger("auth-profiles");
     AuthProfileStore = class {
       filePath;
       lockPath;
@@ -50507,7 +50988,7 @@ var init_auth_profiles = __esm({
           const raw = readFileSync13(this.filePath, "utf-8");
           return JSON.parse(raw);
         } catch (err) {
-          log27.warn("Failed to read auth-profiles.json, starting fresh", { error: String(err) });
+          log28.warn("Failed to read auth-profiles.json, starting fresh", { error: String(err) });
           return { version: 1, profiles: [] };
         }
       }
@@ -50543,7 +51024,7 @@ var init_auth_profiles = __esm({
             }
           } catch {
           }
-          log27.debug("Auth profile lock contention, proceeding without lock");
+          log28.debug("Auth profile lock contention, proceeding without lock");
           return () => {
           };
         }
@@ -50571,7 +51052,7 @@ var init_auth_profiles = __esm({
             data.profiles.push({ ...profile, createdAt: Date.now(), updatedAt: Date.now() });
           }
           this.write(data);
-          log27.info(`Upserted auth profile: ${profile.id} (${profile.provider}/${profile.authType})`);
+          log28.info(`Upserted auth profile: ${profile.id} (${profile.provider}/${profile.authType})`);
         } finally {
           release2();
         }
@@ -50582,13 +51063,13 @@ var init_auth_profiles = __esm({
           const data = this.read();
           const profile = data.profiles.find((p) => p.id === profileId);
           if (!profile) {
-            log27.warn(`Profile not found for token update: ${profileId}`);
+            log28.warn(`Profile not found for token update: ${profileId}`);
             return;
           }
           profile.oauth = tokens;
           profile.updatedAt = Date.now();
           this.write(data);
-          log27.debug(`Updated OAuth tokens for profile: ${profileId}`);
+          log28.debug(`Updated OAuth tokens for profile: ${profileId}`);
         } finally {
           release2();
         }
@@ -50601,7 +51082,7 @@ var init_auth_profiles = __esm({
           data.profiles = data.profiles.filter((p) => p.id !== id);
           if (data.profiles.length < before2) {
             this.write(data);
-            log27.info(`Deleted auth profile: ${id}`);
+            log28.info(`Deleted auth profile: ${id}`);
             return true;
           }
           return false;
@@ -50702,12 +51183,12 @@ function callbackHtml(title, message, success2) {
   <p>${message}</p>
 </div></body></html>`;
 }
-var log28, KNOWN_OAUTH_PROVIDERS, OAuthManager;
+var log29, KNOWN_OAUTH_PROVIDERS, OAuthManager;
 var init_oauth_manager = __esm({
   "../core/dist/llm/oauth-manager.js"() {
     "use strict";
     init_dist();
-    log28 = createLogger("oauth-manager");
+    log29 = createLogger("oauth-manager");
     KNOWN_OAUTH_PROVIDERS = {
       "openai-codex": {
         authorizeUrl: "https://auth.openai.com/oauth/authorize",
@@ -50726,7 +51207,7 @@ var init_oauth_manager = __esm({
       }
       registerProvider(name, config) {
         this.customProviders.set(name, config);
-        log28.info(`Registered custom OAuth provider: ${name}`);
+        log29.info(`Registered custom OAuth provider: ${name}`);
       }
       getProviderConfig(provider) {
         return this.customProviders.get(provider) ?? KNOWN_OAUTH_PROVIDERS[provider];
@@ -50805,10 +51286,10 @@ var init_oauth_manager = __esm({
           });
           pending.server = server;
           server.listen(port, "localhost", () => {
-            log28.info(`OAuth callback server listening on localhost:${port} for ${provider}`);
+            log29.info(`OAuth callback server listening on localhost:${port} for ${provider}`);
           });
           server.on("error", (err) => {
-            log28.error(`Failed to start OAuth callback server on port ${port}`, { error: String(err) });
+            log29.error(`Failed to start OAuth callback server on port ${port}`, { error: String(err) });
             this.cleanupPending(state);
             reject(new Error(`Cannot start callback server: ${err.message}. Port ${port} may be in use.`));
           });
@@ -50873,7 +51354,7 @@ var init_oauth_manager = __esm({
           expiresAt: Date.now() + (data.expires_in ?? 3600) * 1e3,
           accountId: extractAccountId(data.access_token)
         };
-        log28.info(`OAuth token exchange successful for ${provider}`, { accountId: tokens.accountId });
+        log29.info(`OAuth token exchange successful for ${provider}`, { accountId: tokens.accountId });
         return tokens;
       }
       /**
@@ -50910,7 +51391,7 @@ var init_oauth_manager = __esm({
           accountId: profile.oauth.accountId ?? extractAccountId(data.access_token)
         };
         this.profileStore.updateOAuthTokens(profileId, newTokens);
-        log28.info(`Refreshed OAuth token for profile ${profileId}`);
+        log29.info(`Refreshed OAuth token for profile ${profileId}`);
         return newTokens.accessToken;
       }
       /**
@@ -50931,7 +51412,7 @@ var init_oauth_manager = __esm({
           return profile.oauth.accessToken;
         }
         if (profile.oauth.refreshToken) {
-          log28.debug(`Token expiring soon for ${profileId}, refreshing...`);
+          log29.debug(`Token expiring soon for ${profileId}, refreshing...`);
           return this.refreshToken(profileId);
         }
         if (profile.oauth.expiresAt > Date.now()) {
@@ -50976,7 +51457,7 @@ var init_oauth_manager = __esm({
           clearTimeout(pending.timeoutHandle);
         if (pending.server) {
           pending.server.close(() => {
-            log28.debug(`Closed OAuth callback server for state ${state.slice(0, 8)}...`);
+            log29.debug(`Closed OAuth callback server for state ${state.slice(0, 8)}...`);
           });
         }
         this.pendingLogins.delete(state);
@@ -51009,7 +51490,7 @@ function buildTiers(providerNames, defaultProvider) {
   }
   return tiers;
 }
-var log29, ALL_COMPLEXITY, LLMRouter, PROVIDER_DISPLAY_NAMES, BUILTIN_MODEL_CATALOG;
+var log30, ALL_COMPLEXITY, LLMRouter, PROVIDER_DISPLAY_NAMES, BUILTIN_MODEL_CATALOG;
 var init_router = __esm({
   "../core/dist/llm/router.js"() {
     "use strict";
@@ -51021,7 +51502,7 @@ var init_router = __esm({
     init_ollama();
     init_auth_profiles();
     init_oauth_manager();
-    log29 = createLogger("llm-router");
+    log30 = createLogger("llm-router");
     ALL_COMPLEXITY = ["simple", "moderate", "complex"];
     LLMRouter = class _LLMRouter {
       providers = /* @__PURE__ */ new Map();
@@ -51078,7 +51559,7 @@ var init_router = __esm({
         };
         const provider = new OpenAIProvider({ ...providerConfig, provider: name }, async () => oauthMgr.getValidToken(profileId));
         this.registerProvider(name, provider);
-        log29.info(`Registered OAuth-backed provider: ${name}`, { profileId, model: providerConfig.model });
+        log30.info(`Registered OAuth-backed provider: ${name}`, { profileId, model: providerConfig.model });
       }
       get defaultProviderName() {
         return this.defaultProvider;
@@ -51110,13 +51591,13 @@ var init_router = __esm({
         if (fatal && !h.degraded) {
           h.degraded = true;
           h.resetMs = this.CIRCUIT_RESET_FATAL_MS;
-          log29.warn(`Provider ${name} immediately degraded (non-retryable error) \u2014 skipping for ${this.CIRCUIT_RESET_FATAL_MS / 6e4} min`);
+          log30.warn(`Provider ${name} immediately degraded (non-retryable error) \u2014 skipping for ${this.CIRCUIT_RESET_FATAL_MS / 6e4} min`);
           return;
         }
         if (h.consecutiveFailures >= this.CIRCUIT_OPEN_AFTER && !h.degraded) {
           h.degraded = true;
           h.resetMs = this.CIRCUIT_RESET_MS;
-          log29.warn(`Provider ${name} marked as degraded after ${h.consecutiveFailures} failures \u2014 skipping for ${this.CIRCUIT_RESET_MS / 6e4} min`);
+          log30.warn(`Provider ${name} marked as degraded after ${h.consecutiveFailures} failures \u2014 skipping for ${this.CIRCUIT_RESET_MS / 6e4} min`);
         }
       }
       isAvailable(name) {
@@ -51127,7 +51608,7 @@ var init_router = __esm({
           return true;
         const resetMs = h.resetMs ?? this.CIRCUIT_RESET_MS;
         if (Date.now() - h.lastFailureAt > resetMs) {
-          log29.info(`Provider ${name} circuit reset \u2014 will retry`);
+          log30.info(`Provider ${name} circuit reset \u2014 will retry`);
           h.degraded = false;
           h.consecutiveFailures = 0;
           return true;
@@ -51136,7 +51617,7 @@ var init_router = __esm({
       }
       registerProvider(name, provider) {
         this.providers.set(name, provider);
-        log29.info(`Registered LLM provider: ${name}`, { model: provider.model });
+        log30.info(`Registered LLM provider: ${name}`, { model: provider.model });
       }
       enableAutoSelect(tiers) {
         this.autoSelect = true;
@@ -51170,15 +51651,15 @@ var init_router = __esm({
         const complexity = _LLMRouter.assessComplexity(request);
         const match = this.providerTiers.find((t) => t.complexity.includes(complexity) && this.providers.has(t.name) && this.isAvailable(t.name));
         if (match) {
-          log29.debug(`Auto-selected provider: ${match.name}`, { complexity });
+          log30.debug(`Auto-selected provider: ${match.name}`, { complexity });
           return match.name;
         }
         const healthy = [...this.providers.keys()].find((n) => this.isAvailable(n));
         if (healthy) {
-          log29.warn(`All tiered providers degraded for complexity=${complexity}, falling back to: ${healthy}`);
+          log30.warn(`All tiered providers degraded for complexity=${complexity}, falling back to: ${healthy}`);
           return healthy;
         }
-        log29.warn("All providers degraded \u2014 using default as last resort");
+        log30.warn("All providers degraded \u2014 using default as last resort");
         return this.defaultProvider;
       }
       getFallbacks(primary) {
@@ -51228,7 +51709,7 @@ var init_router = __esm({
                 timeoutMs: cfg?.timeoutMs
               });
             } catch (err) {
-              log29.warn(`Failed to auto-register OAuth provider ${providerName}`, { error: String(err) });
+              log30.warn(`Failed to auto-register OAuth provider ${providerName}`, { error: String(err) });
             }
           }
         }
@@ -51241,7 +51722,7 @@ var init_router = __esm({
             ...providerNames.filter((n) => n !== effectiveDefault)
           ].filter((n) => providerNames.includes(n));
           router.setFallbackOrder(fallbackOrder);
-          log29.info("Auto-select enabled with fallback", { providers: providerNames, defaultProvider: effectiveDefault, fallbackOrder });
+          log30.info("Auto-select enabled with fallback", { providers: providerNames, defaultProvider: effectiveDefault, fallbackOrder });
         }
         return router;
       }
@@ -51261,7 +51742,7 @@ var init_router = __esm({
           throw new Error(`LLM provider not found: ${primary}. Available: ${[...this.providers.keys()].join(", ")}`);
         }
         request = this.resolveMaxTokens(request, primary);
-        log29.debug(`Sending request to ${primary}`, { model: provider.model, messageCount: request.messages.length });
+        log30.debug(`Sending request to ${primary}`, { model: provider.model, messageCount: request.messages.length });
         const span = startSpan("llm.chat", { provider: primary, model: provider.model });
         const startTime = Date.now();
         let lastError = null;
@@ -51269,27 +51750,27 @@ var init_router = __esm({
           const response = await provider.chat(request);
           this.recordSuccess(primary);
           span.end({ inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens, finishReason: response.finishReason });
-          log29.debug(`Response from ${primary}`, { tokens: response.usage, finishReason: response.finishReason });
+          log30.debug(`Response from ${primary}`, { tokens: response.usage, finishReason: response.finishReason });
           this.emitLog(primary, provider.model, request, response, Date.now() - startTime);
           return response;
         } catch (error) {
           lastError = error;
           this.recordFailure(primary, error);
-          log29.error(`LLM request failed for ${primary}`, { error: String(error) });
+          log30.error(`LLM request failed for ${primary}`, { error: String(error) });
           for (const fallbackName of this.getFallbacks(primary)) {
             const fb = this.providers.get(fallbackName);
-            log29.info(`Falling back to ${fallbackName}`, { model: fb.model });
+            log30.info(`Falling back to ${fallbackName}`, { model: fb.model });
             try {
               const response = await fb.chat(request);
               this.recordSuccess(fallbackName);
               span.end({ inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens, finishReason: response.finishReason });
-              log29.info(`Fallback to ${fallbackName} succeeded`);
+              log30.info(`Fallback to ${fallbackName} succeeded`);
               this.emitLog(fallbackName, fb.model, request, response, Date.now() - startTime);
               return response;
             } catch (fbError) {
               lastError = fbError;
               this.recordFailure(fallbackName, fbError);
-              log29.error(`Fallback ${fallbackName} also failed`, { error: String(fbError) });
+              log30.error(`Fallback ${fallbackName} also failed`, { error: String(fbError) });
             }
           }
           span.setError(lastError instanceof Error ? lastError : String(lastError));
@@ -51307,7 +51788,7 @@ var init_router = __esm({
         const span = startSpan("llm.chatStream", { provider: primary, model: provider.model });
         const startTime = Date.now();
         if (!provider.chatStream) {
-          log29.debug(`Provider ${primary} does not support streaming, falling back to non-stream`);
+          log30.debug(`Provider ${primary} does not support streaming, falling back to non-stream`);
           const response = await provider.chat(request);
           if (response.content)
             onEvent({ type: "text_delta", text: response.content });
@@ -51331,10 +51812,10 @@ var init_router = __esm({
             span.end();
             throw lastError;
           }
-          log29.error(`LLM stream request failed for ${primary}`, { error: String(error) });
+          log30.error(`LLM stream request failed for ${primary}`, { error: String(error) });
           for (const fallbackName of this.getFallbacks(primary)) {
             const fb = this.providers.get(fallbackName);
-            log29.info(`Stream fallback to ${fallbackName}`);
+            log30.info(`Stream fallback to ${fallbackName}`);
             try {
               let response;
               if (fb.chatStream) {
@@ -51348,14 +51829,14 @@ var init_router = __esm({
               this.recordSuccess(fallbackName);
               span.end({ inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens, finishReason: response.finishReason });
               this.emitLog(fallbackName, fb.model, request, response, Date.now() - startTime);
-              log29.info(`Stream fallback to ${fallbackName} succeeded`);
+              log30.info(`Stream fallback to ${fallbackName} succeeded`);
               return response;
             } catch (fbError) {
               lastError = fbError;
               this.recordFailure(fallbackName, fbError);
               if (signal?.aborted)
                 break;
-              log29.error(`Stream fallback ${fallbackName} failed`, { error: String(fbError) });
+              log30.error(`Stream fallback ${fallbackName} failed`, { error: String(fbError) });
             }
           }
           span.setError(lastError instanceof Error ? lastError : String(lastError));
@@ -51382,7 +51863,7 @@ var init_router = __esm({
           throw new Error(`Cannot set default to unknown provider: ${name}. Available: ${[...this.providers.keys()].join(", ")}`);
         }
         this.defaultProvider = name;
-        log29.info(`Default LLM provider updated to: ${name}`);
+        log30.info(`Default LLM provider updated to: ${name}`);
         const providerNames = this.listProviders();
         if (this.autoSelect && providerNames.length > 1) {
           this.providerTiers = buildTiers(providerNames, name);
@@ -51449,7 +51930,7 @@ var init_router = __esm({
           ...this.customModelConfigs.get(providerName) ?? {},
           ...config
         });
-        log29.info(`Updated model config for ${providerName}`, config);
+        log30.info(`Updated model config for ${providerName}`, config);
       }
       setProviderEnabled(providerName, enabled) {
         if (enabled) {
@@ -51457,7 +51938,7 @@ var init_router = __esm({
         } else {
           this.disabledProviders.add(providerName);
         }
-        log29.info(`Provider ${providerName} ${enabled ? "enabled" : "disabled"}`);
+        log30.info(`Provider ${providerName} ${enabled ? "enabled" : "disabled"}`);
       }
       isProviderEnabled(providerName) {
         return !this.disabledProviders.has(providerName);
@@ -51581,12 +52062,12 @@ var init_router = __esm({
 import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync2 } from "node:fs";
 import { join as join11 } from "node:path";
 import { homedir as homedir6 } from "node:os";
-var log30, LLMLogger;
+var log31, LLMLogger;
 var init_llm_logger = __esm({
   "../core/dist/llm/llm-logger.js"() {
     "use strict";
     init_dist();
-    log30 = createLogger("llm-logger");
+    log31 = createLogger("llm-logger");
     LLMLogger = class {
       logDir;
       enabled;
@@ -51597,7 +52078,7 @@ var init_llm_logger = __esm({
           try {
             mkdirSync11(this.logDir, { recursive: true });
           } catch {
-            log30.warn("Failed to create LLM log directory", { dir: this.logDir });
+            log31.warn("Failed to create LLM log directory", { dir: this.logDir });
             this.enabled = false;
           }
         }
@@ -51611,7 +52092,7 @@ var init_llm_logger = __esm({
           const line2 = JSON.stringify(entry) + "\n";
           appendFileSync2(filePath, line2, "utf-8");
         } catch (err) {
-          log30.warn("Failed to write LLM log entry", { error: String(err) });
+          log31.warn("Failed to write LLM log entry", { error: String(err) });
         }
       }
     };
@@ -51637,12 +52118,12 @@ var init_enhanced_role_loader = __esm({
 
 // ../core/dist/external-gateway.js
 import { createHmac, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
-var log31, ExternalAgentGateway, GatewayError;
+var log32, ExternalAgentGateway, GatewayError;
 var init_external_gateway = __esm({
   "../core/dist/external-gateway.js"() {
     "use strict";
     init_dist();
-    log31 = createLogger("external-gateway");
+    log32 = createLogger("external-gateway");
     ExternalAgentGateway = class {
       config;
       registrations = /* @__PURE__ */ new Map();
@@ -51688,14 +52169,14 @@ var init_external_gateway = __esm({
               if (this.store) {
                 await this.store.saveRegistration(reg);
               }
-              log31.info("Recreated Markus agent for external registration", { externalAgentId: reg.externalAgentId, markusAgentId: created.id });
+              log32.info("Recreated Markus agent for external registration", { externalAgentId: reg.externalAgentId, markusAgentId: created.id });
             } catch (err) {
-              log31.error("Failed to recreate Markus agent for external registration", { externalAgentId: reg.externalAgentId, error: String(err) });
+              log32.error("Failed to recreate Markus agent for external registration", { externalAgentId: reg.externalAgentId, error: String(err) });
             }
           }
         }
         if (rows.length > 0) {
-          log31.info("Loaded external agent registrations from store", { count: rows.length });
+          log32.info("Loaded external agent registrations from store", { count: rows.length });
         }
         return rows.length;
       }
@@ -51718,7 +52199,7 @@ var init_external_gateway = __esm({
             const created = await this.agentCreator({ name: agentName, orgId: orgId2, capabilities });
             markusAgentId = created.id;
           } catch (err) {
-            log31.error("Failed to create Markus agent for external registration", { externalAgentId, error: String(err) });
+            log32.error("Failed to create Markus agent for external registration", { externalAgentId, error: String(err) });
             throw new GatewayError(`Failed to create internal agent: ${String(err)}`, 500);
           }
         }
@@ -51735,9 +52216,9 @@ var init_external_gateway = __esm({
         this.registrations.set(key2, registration);
         this.orgAgentCounts.set(orgId2, orgCount + 1);
         if (this.store) {
-          await this.store.saveRegistration(registration).catch((err) => log31.error("Failed to persist registration", { externalAgentId, error: String(err) }));
+          await this.store.saveRegistration(registration).catch((err) => log32.error("Failed to persist registration", { externalAgentId, error: String(err) }));
         }
-        log31.info("External agent registered", { externalAgentId, orgId: orgId2, markusAgentId });
+        log32.info("External agent registered", { externalAgentId, orgId: orgId2, markusAgentId });
         return registration;
       }
       authenticate(request) {
@@ -51767,7 +52248,7 @@ var init_external_gateway = __esm({
           expiresAt: Date.now() + this.config.tokenExpiryMs
         };
         const token = this.signToken(tokenPayload);
-        log31.info("External agent authenticated", { externalAgentId, orgId: orgId2, markusAgentId: registration.markusAgentId });
+        log32.info("External agent authenticated", { externalAgentId, orgId: orgId2, markusAgentId: registration.markusAgentId });
         return {
           token,
           externalAgentId,
@@ -51832,7 +52313,7 @@ var init_external_gateway = __esm({
           const response = await this.messageRouter(token.markusAgentId, `[${message.type.toUpperCase()}] ${message.content}`, token.externalAgentId);
           return { success: true, messageId, response };
         } catch (err) {
-          log31.error("Message routing failed", { messageId, error: String(err) });
+          log32.error("Message routing failed", { messageId, error: String(err) });
           return { success: false, messageId, error: String(err) };
         }
       }
@@ -51858,7 +52339,7 @@ var init_external_gateway = __esm({
             this.store.updateRegistration(externalAgentId, orgId2, { connected: false }).catch(() => {
             });
           }
-          log31.info("External agent disconnected", { externalAgentId, orgId: orgId2 });
+          log32.info("External agent disconnected", { externalAgentId, orgId: orgId2 });
         }
       }
       async unregister(externalAgentId, orgId2) {
@@ -51870,9 +52351,9 @@ var init_external_gateway = __esm({
         const count = this.orgAgentCounts.get(orgId2) ?? 1;
         this.orgAgentCounts.set(orgId2, Math.max(0, count - 1));
         if (this.store) {
-          await this.store.deleteRegistration(externalAgentId, orgId2).catch((err) => log31.error("Failed to delete registration from store", { externalAgentId, error: String(err) }));
+          await this.store.deleteRegistration(externalAgentId, orgId2).catch((err) => log32.error("Failed to delete registration from store", { externalAgentId, error: String(err) }));
         }
-        log31.info("External agent unregistered", { externalAgentId, orgId: orgId2 });
+        log32.info("External agent unregistered", { externalAgentId, orgId: orgId2 });
         return reg;
       }
       listRegistrations(orgId2) {
@@ -52176,12 +52657,12 @@ var init_markus_handbook = __esm({
 });
 
 // ../core/dist/gateway/sync-handler.js
-var log32, GatewaySyncHandler;
+var log33, GatewaySyncHandler;
 var init_sync_handler = __esm({
   "../core/dist/gateway/sync-handler.js"() {
     "use strict";
     init_dist();
-    log32 = createLogger("gateway-sync");
+    log33 = createLogger("gateway-sync");
     GatewaySyncHandler = class {
       tasks;
       messages;
@@ -52212,9 +52693,9 @@ var init_sync_handler = __esm({
           for (const ct of req.completedTasks) {
             try {
               this.tasks.updateTaskStatus(ct.taskId, "completed", `ext:${markusAgentId}`);
-              log32.info("External agent completed task", { markusAgentId, taskId: ct.taskId });
+              log33.info("External agent completed task", { markusAgentId, taskId: ct.taskId });
             } catch (e) {
-              log32.warn("Failed to complete task from sync", { taskId: ct.taskId, error: String(e) });
+              log33.warn("Failed to complete task from sync", { taskId: ct.taskId, error: String(e) });
             }
           }
         }
@@ -52222,9 +52703,9 @@ var init_sync_handler = __esm({
           for (const ft of req.failedTasks) {
             try {
               this.tasks.updateTaskStatus(ft.taskId, "failed", `ext:${markusAgentId}`);
-              log32.info("External agent failed task", { markusAgentId, taskId: ft.taskId, error: ft.error });
+              log33.info("External agent failed task", { markusAgentId, taskId: ft.taskId, error: ft.error });
             } catch (e) {
-              log32.warn("Failed to update task failure from sync", { taskId: ft.taskId, error: String(e) });
+              log33.warn("Failed to update task failure from sync", { taskId: ft.taskId, error: String(e) });
             }
           }
         }
@@ -52241,7 +52722,7 @@ var init_sync_handler = __esm({
             try {
               this.messages.deliver(markusAgentId, msg.to, msg.content);
             } catch (e) {
-              log32.warn("Failed to deliver message from sync", { to: msg.to, error: String(e) });
+              log33.warn("Failed to deliver message from sync", { to: msg.to, error: String(e) });
             }
           }
         }
@@ -52297,26 +52778,26 @@ var init_gateway = __esm({
 // ../core/dist/review-service.js
 import { exec as execCb } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-var execAsync, log33;
+var execAsync, log34;
 var init_review_service = __esm({
   "../core/dist/review-service.js"() {
     "use strict";
     init_dist();
     execAsync = promisify2(execCb);
-    log33 = createLogger("review-service");
+    log34 = createLogger("review-service");
   }
 });
 
 // ../core/dist/workspace-manager.js
 import { exec as execCb2 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-var execAsync2, log34;
+var execAsync2, log35;
 var init_workspace_manager = __esm({
   "../core/dist/workspace-manager.js"() {
     "use strict";
     init_dist();
     execAsync2 = promisify3(execCb2);
-    log34 = createLogger("workspace-manager");
+    log35 = createLogger("workspace-manager");
   }
 });
 
@@ -52339,26 +52820,27 @@ var init_tools = __esm({
     init_a2a_structured();
     init_task_tools();
     init_memory();
+    init_subagent();
   }
 });
 
 // ../core/dist/tool-profiles.js
-var log35;
+var log36;
 var init_tool_profiles = __esm({
   "../core/dist/tool-profiles.js"() {
     "use strict";
     init_dist();
-    log35 = createLogger("tool-profiles");
+    log36 = createLogger("tool-profiles");
   }
 });
 
 // ../core/dist/skills/registry.js
-var log36, InMemorySkillRegistry;
+var log37, InMemorySkillRegistry;
 var init_registry = __esm({
   "../core/dist/skills/registry.js"() {
     "use strict";
     init_dist();
-    log36 = createLogger("skill-registry");
+    log37 = createLogger("skill-registry");
     InMemorySkillRegistry = class _InMemorySkillRegistry {
       skills = /* @__PURE__ */ new Map();
       aliases = /* @__PURE__ */ new Map();
@@ -52368,18 +52850,18 @@ var init_registry = __esm({
       register(skill) {
         const name = skill.manifest.name;
         if (this.skills.has(name)) {
-          log36.warn(`Skill ${name} already registered, overwriting`);
+          log37.warn(`Skill ${name} already registered, overwriting`);
         }
         this.skills.set(name, skill);
         this.aliases.set(_InMemorySkillRegistry.normalize(name), name);
-        log36.info(`Skill registered: ${name} v${skill.manifest.version}`, {
+        log37.info(`Skill registered: ${name} v${skill.manifest.version}`, {
           hasInstructions: !!skill.manifest.instructions
         });
       }
       unregister(skillName) {
         this.skills.delete(skillName);
         this.aliases.delete(_InMemorySkillRegistry.normalize(skillName));
-        log36.info(`Skill unregistered: ${skillName}`);
+        log37.info(`Skill unregistered: ${skillName}`);
       }
       get(skillName) {
         return this.skills.get(skillName) ?? this.skills.get(this.aliases.get(_InMemorySkillRegistry.normalize(skillName)) ?? "");
@@ -52451,12 +52933,12 @@ function readSkillInstructions(skillDir) {
     return void 0;
   }
 }
-var log37;
+var log38;
 var init_loader = __esm({
   "../core/dist/skills/loader.js"() {
     "use strict";
     init_dist();
-    log37 = createLogger("skill-loader");
+    log38 = createLogger("skill-loader");
   }
 });
 
@@ -52540,7 +53022,7 @@ function discoverSkillsInDir(dir) {
           results.push({ manifest, path: skillDir, source: dir });
         }
       } catch (err) {
-        log38.warn(`Invalid SKILL.md in ${skillDir}: ${err}`);
+        log39.warn(`Invalid SKILL.md in ${skillDir}: ${err}`);
       }
       continue;
     }
@@ -52556,14 +53038,14 @@ async function createDefaultSkillRegistry(options) {
     const found = discoverSkillsInDir(dir);
     for (const { manifest, path: skillPath } of found) {
       if (registry.get(manifest.name)) {
-        log38.debug(`Skill ${manifest.name} already registered, skipping ${skillPath}`);
+        log39.debug(`Skill ${manifest.name} already registered, skipping ${skillPath}`);
         continue;
       }
       manifest.sourcePath = skillPath;
       if (isBuiltin)
         manifest.builtIn = true;
       registry.register({ manifest });
-      log38.info(`Loaded skill: ${manifest.name} from ${skillPath}`, {
+      log39.info(`Loaded skill: ${manifest.name} from ${skillPath}`, {
         hasInstructions: !!manifest.instructions,
         builtIn: isBuiltin
       });
@@ -52571,7 +53053,7 @@ async function createDefaultSkillRegistry(options) {
   }
   return registry;
 }
-var log38, WELL_KNOWN_SKILL_DIRS;
+var log39, WELL_KNOWN_SKILL_DIRS;
 var init_skills = __esm({
   "../core/dist/skills/index.js"() {
     "use strict";
@@ -52579,7 +53061,7 @@ var init_skills = __esm({
     init_dist();
     init_registry();
     init_loader();
-    log38 = createLogger("skill-registry");
+    log39 = createLogger("skill-registry");
     WELL_KNOWN_SKILL_DIRS = [
       join13(homedir7(), ".markus", "skills"),
       join13(homedir7(), ".claude", "skills"),
@@ -52797,12 +53279,12 @@ function createDefaultTemplateRegistry() {
   }
   return registry;
 }
-var log39, TemplateRegistry;
+var log40, TemplateRegistry;
 var init_registry2 = __esm({
   "../core/dist/templates/registry.js"() {
     "use strict";
     init_dist();
-    log39 = createLogger("template-registry");
+    log40 = createLogger("template-registry");
     TemplateRegistry = class {
       templates = /* @__PURE__ */ new Map();
       persistence;
@@ -52825,16 +53307,16 @@ var init_registry2 = __esm({
               loaded++;
             }
           }
-          log39.info(`Synced ${loaded} templates from database`, { total: this.templates.size });
+          log40.info(`Synced ${loaded} templates from database`, { total: this.templates.size });
           return loaded;
         } catch (err) {
-          log39.warn("Failed to sync templates from database", { error: String(err) });
+          log40.warn("Failed to sync templates from database", { error: String(err) });
           return 0;
         }
       }
       register(template) {
         this.templates.set(template.id, template);
-        log39.info(`Template registered: ${template.name} (${template.id})`, {
+        log40.info(`Template registered: ${template.name} (${template.id})`, {
           source: template.source,
           category: template.category
         });
@@ -52896,12 +53378,12 @@ var init_templates = __esm({
 });
 
 // ../core/dist/workflow/engine.js
-var log40, WorkflowEngine;
+var log41, WorkflowEngine;
 var init_engine = __esm({
   "../core/dist/workflow/engine.js"() {
     "use strict";
     init_dist();
-    log40 = createLogger("workflow-engine");
+    log41 = createLogger("workflow-engine");
     WorkflowEngine = class {
       executor;
       executions = /* @__PURE__ */ new Map();
@@ -52922,7 +53404,7 @@ var init_engine = __esm({
           try {
             handler4(event);
           } catch (err) {
-            log40.warn("Event handler error", { error: String(err) });
+            log41.warn("Event handler error", { error: String(err) });
           }
         }
       }
@@ -53017,7 +53499,7 @@ var init_engine = __esm({
         };
         this.executions.set(executionId, execution);
         this.emit({ type: "workflow_started", executionId, timestamp: /* @__PURE__ */ new Date() });
-        log40.info("Workflow started", { executionId, workflowId: def.id, stepCount: def.steps.length });
+        log41.info("Workflow started", { executionId, workflowId: def.id, stepCount: def.steps.length });
         try {
           await this.executeGraph(def, execution);
           if (execution.status === "cancelled")
@@ -53030,13 +53512,13 @@ var init_engine = __esm({
           execution.status = "completed";
           execution.completedAt = /* @__PURE__ */ new Date();
           this.emit({ type: "workflow_completed", executionId, timestamp: /* @__PURE__ */ new Date(), data: execution.outputs });
-          log40.info("Workflow completed", { executionId, elapsed: Date.now() - execution.startedAt.getTime() });
+          log41.info("Workflow completed", { executionId, elapsed: Date.now() - execution.startedAt.getTime() });
         } catch (err) {
           execution.status = "failed";
           execution.error = String(err);
           execution.completedAt = /* @__PURE__ */ new Date();
           this.emit({ type: "workflow_failed", executionId, timestamp: /* @__PURE__ */ new Date(), data: { error: String(err) } });
-          log40.error("Workflow failed", { executionId, error: String(err) });
+          log41.error("Workflow failed", { executionId, error: String(err) });
         }
         return execution;
       }
@@ -53076,7 +53558,7 @@ var init_engine = __esm({
           const promises = readySteps.map((stepId) => {
             const stepDef = stepDefs.get(stepId);
             return this.executeStep(stepDef, execution).catch((err) => {
-              log40.error("Step execution error", { stepId, error: String(err) });
+              log41.error("Step execution error", { stepId, error: String(err) });
             });
           });
           await Promise.all(promises);
@@ -53167,7 +53649,7 @@ var init_engine = __esm({
               timestamp: /* @__PURE__ */ new Date(),
               data: { attempt: stepExec.retryCount, maxRetries }
             });
-            log40.warn("Step retrying", { stepId: stepDef.id, attempt: stepExec.retryCount });
+            log41.warn("Step retrying", { stepId: stepDef.id, attempt: stepExec.retryCount });
           } else {
             stepExec.status = "failed";
             stepExec.error = String(err);
@@ -53355,7 +53837,7 @@ var init_engine = __esm({
           const fn = new Function("steps", "inputs", `return !!(${expr})`);
           return fn(steps, execution.inputs);
         } catch {
-          log40.warn("Expression evaluation failed", { expr });
+          log41.warn("Expression evaluation failed", { expr });
           return false;
         }
       }
@@ -53420,7 +53902,7 @@ function loadTeamTemplateFromDir(dirPath) {
       norms: existsSync19(normsPath) ? readFileSync16(normsPath, "utf-8") : void 0
     };
   } catch (err) {
-    log41.warn(`Failed to load team template from ${dirPath}`, { error: String(err) });
+    log42.warn(`Failed to load team template from ${dirPath}`, { error: String(err) });
     return null;
   }
 }
@@ -53443,7 +53925,7 @@ function createDefaultTeamTemplates() {
     templatesDir = resolve11(process.cwd(), "templates", "teams");
   }
   if (!existsSync19(templatesDir)) {
-    log41.warn(`Team templates directory not found: ${templatesDir}`);
+    log42.warn(`Team templates directory not found: ${templatesDir}`);
     return registry;
   }
   const entries2 = readdirSync7(templatesDir, { withFileTypes: true });
@@ -53455,22 +53937,21 @@ function createDefaultTeamTemplates() {
       registry.register(tpl);
     }
   }
-  log41.info(`Loaded ${registry.list().length} team templates from ${templatesDir}`);
+  log42.info(`Loaded ${registry.list().length} team templates from ${templatesDir}`);
   return registry;
 }
-var log41, TeamTemplateRegistry;
+var log42, TeamTemplateRegistry;
 var init_team_template = __esm({
   "../core/dist/workflow/team-template.js"() {
     "use strict";
     init_dist();
-    log41 = createLogger("team-template");
+    log42 = createLogger("team-template");
     TeamTemplateRegistry = class {
       templates = /* @__PURE__ */ new Map();
       register(template) {
         this.templates.set(template.id, template);
-        log41.info(`Team template registered: ${template.name}`, {
-          members: template.members.length,
-          hasWorkflow: !!template.workflow
+        log42.info(`Team template registered: ${template.name}`, {
+          members: template.members.length
         });
       }
       unregister(id) {
@@ -53508,13 +53989,13 @@ var init_types = __esm({
 });
 
 // ../core/dist/federation/federation-manager.js
-var log42;
+var log43;
 var init_federation_manager = __esm({
   "../core/dist/federation/federation-manager.js"() {
     "use strict";
     init_dist();
     init_types();
-    log42 = createLogger("federation");
+    log43 = createLogger("federation");
   }
 });
 
@@ -53528,266 +54009,12 @@ var init_federation = __esm({
 });
 
 // ../core/dist/agent-snapshot.js
-var log43;
+var log44;
 var init_agent_snapshot = __esm({
   "../core/dist/agent-snapshot.js"() {
     "use strict";
     init_dist();
-    log43 = createLogger("agent-snapshot");
-  }
-});
-
-// ../core/dist/prompt-studio.js
-var log44, PromptStudio;
-var init_prompt_studio = __esm({
-  "../core/dist/prompt-studio.js"() {
-    "use strict";
-    init_dist();
-    log44 = createLogger("prompt-studio");
-    PromptStudio = class {
-      executor;
-      prompts = /* @__PURE__ */ new Map();
-      abTests = /* @__PURE__ */ new Map();
-      evaluations = [];
-      constructor(executor) {
-        this.executor = executor;
-      }
-      setExecutor(executor) {
-        this.executor = executor;
-      }
-      // ── Prompt Management ──────────────────────────────────────────────────
-      createPrompt(opts) {
-        const id = generateId("prompt");
-        const version2 = {
-          id: generateId("pv"),
-          promptId: id,
-          version: 1,
-          content: opts.content,
-          variables: this.extractVariables(opts.content),
-          author: opts.author,
-          createdAt: /* @__PURE__ */ new Date()
-        };
-        const prompt = {
-          id,
-          name: opts.name,
-          description: opts.description,
-          category: opts.category,
-          currentVersion: 1,
-          versions: [version2],
-          tags: opts.tags ?? [],
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        this.prompts.set(id, prompt);
-        log44.info("Prompt created", { promptId: id, name: opts.name });
-        return prompt;
-      }
-      updatePrompt(promptId, content, author, changelog) {
-        const prompt = this.prompts.get(promptId);
-        if (!prompt)
-          throw new Error(`Prompt ${promptId} not found`);
-        const newVersionNum = prompt.currentVersion + 1;
-        const version2 = {
-          id: generateId("pv"),
-          promptId,
-          version: newVersionNum,
-          content,
-          variables: this.extractVariables(content),
-          author,
-          createdAt: /* @__PURE__ */ new Date(),
-          changelog
-        };
-        prompt.versions.push(version2);
-        prompt.currentVersion = newVersionNum;
-        prompt.updatedAt = /* @__PURE__ */ new Date();
-        log44.info("Prompt updated", { promptId, version: newVersionNum });
-        return version2;
-      }
-      getPrompt(promptId) {
-        return this.prompts.get(promptId);
-      }
-      getVersion(promptId, version2) {
-        const prompt = this.prompts.get(promptId);
-        return prompt?.versions.find((v) => v.version === version2);
-      }
-      listPrompts(category) {
-        const all = [...this.prompts.values()];
-        if (!category)
-          return all;
-        return all.filter((p) => p.category === category);
-      }
-      searchPrompts(query2) {
-        const lower = query2.toLowerCase();
-        return [...this.prompts.values()].filter((p) => p.name.toLowerCase().includes(lower) || p.description.toLowerCase().includes(lower) || p.tags.some((t) => t.toLowerCase().includes(lower)));
-      }
-      deletePrompt(promptId) {
-        return this.prompts.delete(promptId);
-      }
-      renderPrompt(promptId, variables, version2) {
-        const prompt = this.prompts.get(promptId);
-        if (!prompt)
-          throw new Error(`Prompt ${promptId} not found`);
-        const v = version2 ? prompt.versions.find((pv) => pv.version === version2) : prompt.versions.find((pv) => pv.version === prompt.currentVersion);
-        if (!v)
-          throw new Error(`Version ${version2 ?? prompt.currentVersion} not found`);
-        return this.interpolatePrompt(v.content, variables);
-      }
-      // ── A/B Testing ────────────────────────────────────────────────────────
-      createABTest(opts) {
-        const prompt = this.prompts.get(opts.promptId);
-        if (!prompt)
-          throw new Error(`Prompt ${opts.promptId} not found`);
-        const findVersion2 = (v) => prompt.versions.find((pv) => pv.version === v);
-        if (!findVersion2(opts.variantA))
-          throw new Error(`Variant A (v${opts.variantA}) not found`);
-        if (!findVersion2(opts.variantB))
-          throw new Error(`Variant B (v${opts.variantB}) not found`);
-        const test = {
-          id: generateId("ab-test"),
-          name: opts.name,
-          promptId: opts.promptId,
-          variantA: opts.variantA,
-          variantB: opts.variantB,
-          splitRatio: opts.splitRatio ?? 0.5,
-          status: "draft",
-          metrics: {
-            variantATrials: 0,
-            variantBTrials: 0,
-            variantAScores: [],
-            variantBScores: []
-          },
-          createdAt: /* @__PURE__ */ new Date()
-        };
-        this.abTests.set(test.id, test);
-        log44.info("A/B test created", { testId: test.id, promptId: opts.promptId });
-        return test;
-      }
-      startABTest(testId) {
-        const test = this.abTests.get(testId);
-        if (!test || test.status !== "draft")
-          return false;
-        test.status = "running";
-        return true;
-      }
-      /** Pick which variant to use based on the split ratio */
-      pickVariant(testId) {
-        const test = this.abTests.get(testId);
-        if (!test || test.status !== "running") {
-          throw new Error(`A/B test ${testId} is not running`);
-        }
-        const isA = Math.random() < test.splitRatio;
-        return isA ? { version: test.variantA, variant: "A" } : { version: test.variantB, variant: "B" };
-      }
-      recordABResult(testId, variant, score) {
-        const test = this.abTests.get(testId);
-        if (!test || test.status !== "running")
-          return;
-        if (variant === "A") {
-          test.metrics.variantATrials++;
-          test.metrics.variantAScores.push(score);
-        } else {
-          test.metrics.variantBTrials++;
-          test.metrics.variantBScores.push(score);
-        }
-      }
-      completeABTest(testId) {
-        const test = this.abTests.get(testId);
-        if (!test || test.status !== "running")
-          return void 0;
-        test.status = "completed";
-        test.completedAt = /* @__PURE__ */ new Date();
-        log44.info("A/B test completed", {
-          testId,
-          variantAAvg: this.average(test.metrics.variantAScores),
-          variantBAvg: this.average(test.metrics.variantBScores)
-        });
-        return test;
-      }
-      getABTestResults(testId) {
-        const test = this.abTests.get(testId);
-        if (!test)
-          return void 0;
-        const avgA = this.average(test.metrics.variantAScores);
-        const avgB = this.average(test.metrics.variantBScores);
-        const diff = Math.abs(avgA - avgB);
-        const totalTrials = test.metrics.variantATrials + test.metrics.variantBTrials;
-        const confidence = totalTrials > 0 ? Math.min(1, totalTrials / 100 * (diff / Math.max(avgA, avgB, 0.01))) : 0;
-        let winner = "tie";
-        if (diff > 0.05)
-          winner = avgA > avgB ? "A" : "B";
-        return { test, variantAAvg: avgA, variantBAvg: avgB, winner, confidence };
-      }
-      listABTests(promptId) {
-        const all = [...this.abTests.values()];
-        if (!promptId)
-          return all;
-        return all.filter((t) => t.promptId === promptId);
-      }
-      // ── Evaluation ─────────────────────────────────────────────────────────
-      async evaluate(promptId, version2, testInput, variables = {}, evaluator) {
-        if (!this.executor)
-          throw new Error("No prompt executor configured");
-        const rendered = this.renderPrompt(promptId, variables, version2);
-        const fullPrompt = `${rendered}
-
-Input: ${testInput}`;
-        const { output, latencyMs, tokenCount } = await this.executor.execute(fullPrompt, variables);
-        const result = {
-          id: generateId("eval"),
-          promptId,
-          version: version2,
-          testInput,
-          output,
-          score: 0,
-          latencyMs,
-          tokenCount,
-          evaluatedAt: /* @__PURE__ */ new Date(),
-          evaluator
-        };
-        this.evaluations.push(result);
-        return result;
-      }
-      scoreEvaluation(evaluationId, score, notes) {
-        const ev = this.evaluations.find((e) => e.id === evaluationId);
-        if (!ev)
-          return false;
-        ev.score = Math.max(0, Math.min(10, score));
-        if (notes)
-          ev.notes = notes;
-        return true;
-      }
-      getEvaluations(promptId, version2) {
-        return this.evaluations.filter((e) => e.promptId === promptId && (version2 === void 0 || e.version === version2));
-      }
-      getEvaluationSummary(promptId, version2) {
-        const evals = this.getEvaluations(promptId, version2);
-        if (evals.length === 0)
-          return { avgScore: 0, avgLatencyMs: 0, avgTokenCount: 0, count: 0 };
-        return {
-          avgScore: this.average(evals.map((e) => e.score)),
-          avgLatencyMs: this.average(evals.map((e) => e.latencyMs)),
-          avgTokenCount: this.average(evals.map((e) => e.tokenCount)),
-          count: evals.length
-        };
-      }
-      // ── Helpers ────────────────────────────────────────────────────────────
-      extractVariables(content) {
-        const matches2 = content.match(/\{\{(\w+)\}\}/g);
-        if (!matches2)
-          return [];
-        return [...new Set(matches2.map((m) => m.slice(2, -2)))];
-      }
-      interpolatePrompt(content, variables) {
-        return content.replace(/\{\{(\w+)\}\}/g, (_match, name) => {
-          return variables[name] ?? `{{${name}}}`;
-        });
-      }
-      average(arr) {
-        if (arr.length === 0)
-          return 0;
-        return Math.round(arr.reduce((s, v) => s + v, 0) / arr.length * 100) / 100;
-      }
-    };
+    log44 = createLogger("agent-snapshot");
   }
 });
 
@@ -53835,7 +54062,6 @@ var init_dist4 = __esm({
     init_workflow();
     init_federation();
     init_agent_snapshot();
-    init_prompt_studio();
   }
 });
 
@@ -54422,7 +54648,13 @@ var init_org_service = __esm({
         if (!org)
           return;
         const humans = this.listHumanUsers(targetOrgId);
-        this.agentManager.refreshIdentityContexts(targetOrgId, org.name, humans);
+        const teams2 = this.listTeams(targetOrgId).map((t) => ({
+          id: t.id,
+          name: t.name,
+          description: t.description,
+          memberAgentIds: t.memberAgentIds
+        }));
+        this.agentManager.refreshIdentityContexts(targetOrgId, org.name, humans, teams2);
       }
       listAvailableRoles() {
         return this.roleLoader.listAvailableRoles();
@@ -54712,7 +54944,29 @@ var init_org_service = __esm({
           for (const r of roleNames) {
             parts.push(`- \`${r}\``);
           }
+          const templateDirs = this.roleLoader.getTemplateDirs();
+          if (templateDirs.length > 0) {
+            parts.push("");
+            parts.push("**Tip**: You can read existing role templates for reference when writing custom ROLE.md files.");
+            parts.push(`Use \`file_read\` to inspect any template, e.g.: \`file_read("${templateDirs[0]}/developer/ROLE.md")\``);
+            parts.push("This is especially useful for understanding the level of detail and workflow guidance expected in a good ROLE.md.");
+          }
         }
+        parts.push("");
+        parts.push("## Platform Capabilities (reference when writing ROLE.md)");
+        parts.push("");
+        parts.push("When writing custom ROLE.md for agents, reference these platform capabilities where relevant:");
+        parts.push("");
+        parts.push("- **`spawn_subagent`** \u2014 Spawn lightweight in-process subagents for focused subtasks (deep analysis, research, boilerplate generation) without polluting the parent agent's context");
+        parts.push("- **`background_exec`** \u2014 Run long-running commands (builds, test suites, deployments) in background with automatic completion notifications");
+        parts.push("- **`shell_execute`** \u2014 Execute any shell command, including `git` (merge, diff, branch) and `gh` CLI (PRs, issues, releases) for Git/GitHub operations");
+        parts.push("- **Worktree isolation** \u2014 Each task gets an isolated git worktree (`task/<id>` branch). Developers work in isolation; the reviewer merges after approval.");
+        parts.push("- **`web_search` / `web_fetch`** \u2014 Search the web and fetch page content for research, documentation lookup, and real-time information");
+        parts.push("- **Task dependencies** \u2014 Use `blockedBy` to express dependencies between tasks. Blocked tasks auto-start when dependencies complete.");
+        parts.push("- **Deliverables** \u2014 Use `deliverable_create` to register outputs (files, conventions, architecture decisions) as trackable artifacts");
+        parts.push("- **Memory** \u2014 Use `memory_save` / `memory_search` for persistent knowledge across sessions");
+        parts.push("");
+        parts.push("Include workflow guidance in ROLE.md that tells the agent *when* and *how* to use these capabilities for their specific role.");
         return parts.join("\n");
       }
     };
@@ -56587,10 +56841,25 @@ ${c.content}`;
               parts.push(`> ${note}`);
             }
           }
+          if (task.projectId && this.projectService) {
+            const project = this.projectService.getProject(task.projectId);
+            const repo = project?.repositories?.find((r) => r.role === "primary" && r.localPath) ?? project?.repositories?.find((r) => r.localPath);
+            if (repo?.localPath) {
+              const branchName = `task/${task.id}`;
+              const worktreePath = `${repo.localPath}/.worktrees/task-${task.id}`;
+              parts.push("");
+              parts.push("**Git Context:**");
+              parts.push(`- Repository: \`${repo.localPath}\``);
+              parts.push(`- Task branch: \`${branchName}\``);
+              parts.push(`- Base branch: \`${repo.defaultBranch}\``);
+              parts.push(`- Worktree: \`${worktreePath}\``);
+              parts.push(`- To see changes: \`cd ${repo.localPath} && git diff ${repo.defaultBranch}...${branchName}\``);
+            }
+          }
           parts.push("");
           parts.push(`Please review immediately. Use \`task_get\` with task_id "${task.id}" to inspect deliverable files, then either:`);
-          parts.push(`- \`task_update\` with task_id "${task.id}" and status "completed" if the work meets requirements (this approves and completes the task)`);
-          parts.push(`- \`task_update\` with task_id "${task.id}" and a note explaining what needs to change (the system will automatically request revision and re-execute)`);
+          parts.push(`- **Approve**: Review the code, merge the branch (via \`git merge\` or \`gh pr create\` + \`gh pr merge\`), then \`task_update\` with status "completed"`);
+          parts.push(`- **Reject**: If the code has issues or merge conflicts, add a \`task_note\` explaining what needs to change, then \`task_update\` with status "in_progress" to send it back`);
           parts.push("");
           parts.push(`CRITICAL: You MUST ONLY review this specific task (ID: ${task.id}). Do NOT change the status of any other task.`);
           const reviewMessage = parts.join("\n");
@@ -58444,7 +58713,6 @@ var init_api_server = __esm({
       templateRegistry;
       workflowEngine;
       teamTemplateRegistry;
-      promptStudio;
       customGroupChats = [];
       constructor(orgService, taskService, port = 8056) {
         this.orgService = orgService;
@@ -58453,7 +58721,6 @@ var init_api_server = __esm({
         this.ws = new WSBroadcaster();
         this.teamTemplateRegistry = createDefaultTeamTemplates();
         this.templateRegistry = createDefaultTemplateRegistry();
-        this.promptStudio = new PromptStudio();
         const am = this.orgService.getAgentManager();
         if (this.templateRegistry && !am.getTemplateRegistry()) {
           am.setTemplateRegistry(this.templateRegistry);
@@ -62691,6 +62958,37 @@ var init_api_server = __esm({
           }
           return;
         }
+        if (path === "/api/settings/agent" && req.method === "GET") {
+          const am = this.orgService.getAgentManager();
+          this.json(res, 200, { maxToolIterations: am.maxToolIterations });
+          return;
+        }
+        if (path === "/api/settings/agent" && req.method === "POST") {
+          const auth = await this.requireAuth(req, res);
+          if (!auth)
+            return;
+          const body = await this.readBody(req);
+          const am = this.orgService.getAgentManager();
+          let changed = false;
+          if (typeof body["maxToolIterations"] === "number") {
+            am.maxToolIterations = body["maxToolIterations"];
+            changed = true;
+          }
+          if (changed) {
+            try {
+              saveConfig({ agent: { maxToolIterations: am.maxToolIterations } }, this.markusConfigPath);
+            } catch (e) {
+              log51.warn("Failed to persist agent settings to config file", { error: String(e) });
+            }
+            for (const info of am.listAgents()) {
+              const agent = am.getAgent(info.id);
+              if (agent)
+                agent.maxToolIterations = am.maxToolIterations;
+            }
+          }
+          this.json(res, 200, { maxToolIterations: am.maxToolIterations });
+          return;
+        }
         if (path === "/api/settings/llm/models" && req.method === "GET") {
           if (!this.llmRouter) {
             this.json(res, 200, { models: [] });
@@ -63258,207 +63556,6 @@ var init_api_server = __esm({
           this.json(res, 200, { deleted: true });
           return;
         }
-        if (path === "/api/prompts" && req.method === "GET") {
-          const category = url.searchParams.get("category") ?? void 0;
-          const q = url.searchParams.get("q");
-          const prompts = q ? this.promptStudio.searchPrompts(q) : this.promptStudio.listPrompts(category);
-          this.json(res, 200, { prompts });
-          return;
-        }
-        if (path === "/api/prompts" && req.method === "POST") {
-          const auth = await this.requireAuth(req, res);
-          if (!auth)
-            return;
-          const body = await this.readBody(req);
-          const { name, description, category, content, tags } = body;
-          if (!name || !content) {
-            this.json(res, 400, { error: "name and content are required" });
-            return;
-          }
-          const prompt = this.promptStudio.createPrompt({
-            name,
-            description: description ?? "",
-            category: category ?? "general",
-            content,
-            author: auth.userId ?? "user",
-            tags
-          });
-          this.json(res, 201, { prompt });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/[^/]+$/) && req.method === "GET") {
-          const promptId = path.split("/")[3];
-          const prompt = this.promptStudio.getPrompt(promptId);
-          if (!prompt) {
-            this.json(res, 404, { error: "Prompt not found" });
-            return;
-          }
-          this.json(res, 200, { prompt });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/[^/]+$/) && req.method === "DELETE") {
-          const promptId = path.split("/")[3];
-          this.promptStudio.deletePrompt(promptId);
-          this.json(res, 200, { deleted: true });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/[^/]+\/versions$/) && req.method === "POST") {
-          const auth = await this.requireAuth(req, res);
-          if (!auth)
-            return;
-          const promptId = path.split("/")[3];
-          const body = await this.readBody(req);
-          const { content, changelog } = body;
-          if (!content) {
-            this.json(res, 400, { error: "content is required" });
-            return;
-          }
-          try {
-            const version2 = this.promptStudio.updatePrompt(promptId, content, auth.userId ?? "user", changelog);
-            this.json(res, 201, { version: version2 });
-          } catch (err) {
-            this.json(res, 404, { error: String(err) });
-          }
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/[^/]+\/render$/) && req.method === "POST") {
-          const promptId = path.split("/")[3];
-          const body = await this.readBody(req);
-          const { variables, version: version2 } = body;
-          try {
-            const rendered = this.promptStudio.renderPrompt(promptId, variables ?? {}, version2);
-            this.json(res, 200, { rendered });
-          } catch (err) {
-            this.json(res, 400, { error: String(err) });
-          }
-          return;
-        }
-        if (path === "/api/prompts/ab-tests" && req.method === "GET") {
-          const promptId = url.searchParams.get("promptId") ?? void 0;
-          const tests = this.promptStudio.listABTests(promptId);
-          this.json(res, 200, { tests });
-          return;
-        }
-        if (path === "/api/prompts/ab-tests" && req.method === "POST") {
-          const auth = await this.requireAuth(req, res);
-          if (!auth)
-            return;
-          const body = await this.readBody(req);
-          const { name, promptId, variantA, variantB, splitRatio } = body;
-          try {
-            const test = this.promptStudio.createABTest({
-              name,
-              promptId,
-              variantA,
-              variantB,
-              splitRatio
-            });
-            this.json(res, 201, { test });
-          } catch (err) {
-            this.json(res, 400, { error: String(err) });
-          }
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/ab-tests\/[^/]+\/start$/) && req.method === "POST") {
-          const testId = path.split("/")[4];
-          const started = this.promptStudio.startABTest(testId);
-          this.json(res, 200, { started });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/ab-tests\/[^/]+\/complete$/) && req.method === "POST") {
-          const testId = path.split("/")[4];
-          const result = this.promptStudio.completeABTest(testId);
-          if (!result) {
-            this.json(res, 404, { error: "Test not found or not running" });
-            return;
-          }
-          this.json(res, 200, { test: result });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/ab-tests\/[^/]+\/record$/) && req.method === "POST") {
-          const testId = path.split("/")[4];
-          const body = await this.readBody(req);
-          const { variant, score } = body;
-          this.promptStudio.recordABResult(testId, variant, score);
-          this.json(res, 200, { ok: true });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/ab-tests\/[^/]+\/results$/) && req.method === "GET") {
-          const testId = path.split("/")[4];
-          const results = this.promptStudio.getABTestResults(testId);
-          if (!results) {
-            this.json(res, 404, { error: "Test not found" });
-            return;
-          }
-          this.json(res, 200, results);
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/[^/]+\/evaluations$/) && req.method === "GET") {
-          const promptId = path.split("/")[3];
-          const version2 = url.searchParams.get("version") ? parseInt(url.searchParams.get("version"), 10) : void 0;
-          const evaluations = this.promptStudio.getEvaluations(promptId, version2);
-          this.json(res, 200, { evaluations });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/[^/]+\/evaluate$/) && req.method === "POST") {
-          const auth = await this.requireAuth(req, res);
-          if (!auth)
-            return;
-          const promptId = path.split("/")[3];
-          const body = await this.readBody(req);
-          const { version: version2, testInput, variables } = body;
-          if (!testInput || version2 === void 0) {
-            this.json(res, 400, { error: "version and testInput are required" });
-            return;
-          }
-          if (this.llmRouter && !this.promptStudio["executor"]) {
-            this.promptStudio.setExecutor({
-              execute: async (prompt) => {
-                const startMs = Date.now();
-                const response = await this.llmRouter.chat({
-                  messages: [
-                    {
-                      role: "system",
-                      content: "You are a helpful assistant. Respond to the prompt accurately and concisely."
-                    },
-                    { role: "user", content: prompt }
-                  ]
-                });
-                return {
-                  output: response.content,
-                  latencyMs: Date.now() - startMs,
-                  tokenCount: (response.usage?.inputTokens ?? 0) + (response.usage?.outputTokens ?? 0)
-                };
-              }
-            });
-          }
-          try {
-            const result = await this.promptStudio.evaluate(promptId, version2, testInput, variables ?? {}, auth.userId ?? "user");
-            this.json(res, 200, { evaluation: result });
-          } catch (err) {
-            this.json(res, 400, { error: String(err) });
-          }
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/evaluations\/[^/]+\/score$/) && req.method === "POST") {
-          const evaluationId = path.split("/")[4];
-          const body = await this.readBody(req);
-          const { score, notes } = body;
-          const updated = this.promptStudio.scoreEvaluation(evaluationId, score, notes);
-          this.json(res, 200, { updated });
-          return;
-        }
-        if (path.match(/^\/api\/prompts\/[^/]+\/evaluation-summary$/) && req.method === "GET") {
-          const promptId = path.split("/")[3];
-          const version2 = url.searchParams.get("version") ? parseInt(url.searchParams.get("version"), 10) : void 0;
-          if (version2 === void 0) {
-            this.json(res, 400, { error: "version query param is required" });
-            return;
-          }
-          const summary = this.promptStudio.getEvaluationSummary(promptId, version2);
-          this.json(res, 200, { summary });
-          return;
-        }
         if (path === "/api/system/open-path" && req.method === "POST") {
           try {
             const body = await this.readBody(req);
@@ -79362,6 +79459,9 @@ async function createServices(config) {
     taskService,
     mcpServers: config.mcpServers
   });
+  if (config.agent?.maxToolIterations) {
+    agentManager.maxToolIterations = config.agent.maxToolIterations;
+  }
   taskService.setAgentManager(agentManager);
   const orgService = new OrganizationService(agentManager, roleLoader, storage ?? void 0);
   taskService.setOrgService(orgService);
@@ -79797,16 +79897,24 @@ async function startServer(config, values) {
     console.log("  Feishu integration enabled");
   }
   const webPort = config.server.webPort;
-  const webUiLine = webUiDir ? `  Web UI:      http://localhost:${apiPort}  (built-in)` : `  Web UI:      http://localhost:${webPort}  (run: pnpm --filter @markus/web-ui dev)`;
-  console.log(`
+  if (webUiDir) {
+    console.log(`
+  Markus is running!
+
+  Dashboard:   http://localhost:${apiPort}
+
+  Press Ctrl+C to stop.
+  `);
+  } else {
+    console.log(`
   Markus is running!
 
   API Server:  http://localhost:${apiPort}
-${webUiLine}
-  WebUI Comm:  http://localhost:${commPort}
+  Web UI:      http://localhost:${webPort}  (run: pnpm --filter @markus/web-ui dev)
 
   Press Ctrl+C to stop.
   `);
+  }
   orgService.startRestoredAgentsInBackground();
   process.on("SIGINT", () => {
     console.log("\nShutting down...");