@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/chunk-MXAP4UG6.js

@@ -0,0 +1,2956 @@
+import {
+  sleep
+} from "./chunk-SZ2XBPTW.js";
+import {
+  Tool
+} from "./chunk-Q742PSH3.js";
+import {
+  extractApprovalPatterns,
+  matchApprovalPattern,
+  resolveCapability
+} from "./chunk-FII65CN7.js";
+
+// src/team/types.ts
+var TERMINAL_STATUSES = [
+  "completed",
+  "aborted",
+  "failed",
+  "cancelled"
+];
+
+// src/team/task-board.ts
+var TASK_CONFLICT_MAX_RETRIES = 4;
+var TaskConflictError = class extends Error {
+  constructor(message, taskId) {
+    super(message);
+    this.taskId = taskId;
+    this.name = "TaskConflictError";
+  }
+};
+function clone(value) {
+  return structuredClone(value);
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function requireNonEmpty(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error(`${label} must not be empty`);
+  return trimmed;
+}
+function normalizeDeps(taskId, deps) {
+  if (!deps || deps.length === 0) return void 0;
+  const unique = [...new Set(deps.map((d) => requireNonEmpty(d, "dependency ID")))];
+  if (unique.includes(taskId)) throw new Error(`Task "${taskId}" cannot depend on itself`);
+  return unique;
+}
+function isTerminal(status) {
+  return status === "completed" || status === "aborted" || status === "failed" || status === "cancelled";
+}
+function isDependencyFailure(status) {
+  return status === "failed" || status === "cancelled";
+}
+function resolveDependencyStatus(task, lookup) {
+  const deps = task.dependsOn ?? [];
+  if (deps.length === 0) {
+    return {
+      status: task.status === "blocked" ? "pending" : task.status,
+      failedDeps: [],
+      blockedBy: []
+    };
+  }
+  const failedDeps = [];
+  const blockedBy = [];
+  for (const depId of deps) {
+    const dep = lookup.get(depId);
+    if (!dep) {
+      blockedBy.push(depId);
+      continue;
+    }
+    if (dep.status === "completed") continue;
+    if (isDependencyFailure(dep.status)) {
+      failedDeps.push(depId);
+      continue;
+    }
+    blockedBy.push(depId);
+  }
+  if (failedDeps.length > 0) {
+    return { status: "cancelled", failedDeps, blockedBy };
+  }
+  if (blockedBy.length > 0) {
+    return { status: "blocked", failedDeps, blockedBy };
+  }
+  return {
+    status: task.status === "blocked" ? "pending" : task.status,
+    failedDeps: [],
+    blockedBy: []
+  };
+}
+var InMemoryTaskBoardStore = class {
+  members = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  async listMembers() {
+    return [...this.members.values()].map(clone).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async getMember(memberId) {
+    const m = this.members.get(memberId);
+    return m ? clone(m) : void 0;
+  }
+  async putMember(member) {
+    const copy = clone(member);
+    this.members.set(copy.id, copy);
+    return clone(copy);
+  }
+  async listTasks(filter) {
+    let tasks = [...this.tasks.values()];
+    if (filter?.memberId) {
+      tasks = tasks.filter((t) => t.memberId === filter.memberId);
+    }
+    if (filter?.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      tasks = tasks.filter((t) => statuses.includes(t.status));
+    }
+    const sorted = tasks.map(clone).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    if (filter?.limit !== void 0) {
+      return sorted.slice(0, Math.max(0, Math.floor(filter.limit)));
+    }
+    return sorted;
+  }
+  async getTask(taskId) {
+    const t = this.tasks.get(taskId);
+    return t ? clone(t) : void 0;
+  }
+  async putTask(task) {
+    const copy = clone(task);
+    this.tasks.set(copy.id, copy);
+    return clone(copy);
+  }
+};
+var TaskBoard = class {
+  constructor(store) {
+    this.store = store;
+  }
+  async start() {
+    await this.store.start?.();
+  }
+  async stop() {
+    await this.store.stop?.();
+  }
+  // ── Read ───────────────────────────────────────────────────────────
+  async listMembers() {
+    return this.store.listMembers();
+  }
+  async getMember(id) {
+    return this.store.getMember(id);
+  }
+  async listTasks(filter) {
+    return this.store.listTasks(filter);
+  }
+  async getTask(id) {
+    return this.store.getTask(id);
+  }
+  async snapshot() {
+    const [members, tasks] = await Promise.all([
+      this.store.listMembers(),
+      this.store.listTasks()
+    ]);
+    return { members, tasks };
+  }
+  // ── Member mutations ───────────────────────────────────────────────
+  async putMember(member) {
+    return this.retryOnConflict(() => this.store.putMember(member));
+  }
+  // ── Task lifecycle ─────────────────────────────────────────────────
+  /**
+   * Create a new task. Its initial status is computed from dependencies:
+   * `"pending"` if all deps are met, `"blocked"` otherwise, or
+   * `"cancelled"` if a dependency already failed.
+   */
+  async createTask(input) {
+    return this.retryOnConflict(async () => {
+      const id = requireNonEmpty(input.id, "task ID");
+      const existing = await this.store.getTask(id);
+      if (existing) throw new Error(`Task already exists: ${id}`);
+      const ts = now();
+      const task = {
+        id,
+        memberId: input.memberId?.trim() || void 0,
+        title: requireNonEmpty(input.title, "title"),
+        prompt: requireNonEmpty(input.prompt, "prompt"),
+        status: "pending",
+        dependsOn: normalizeDeps(id, input.dependsOn),
+        createdAt: ts,
+        updatedAt: ts
+      };
+      const allTasks = await this.store.listTasks();
+      const lookup = new Map(allTasks.map((t) => [t.id, t]));
+      const resolved = resolveDependencyStatus(task, lookup);
+      const initial = {
+        ...task,
+        status: resolved.status,
+        error: resolved.failedDeps.length > 0 ? `Dependency failed: ${resolved.failedDeps.join(", ")}` : void 0
+      };
+      const stored = await this.store.putTask(initial);
+      return {
+        task: stored,
+        transitions: [{ task: stored, reason: "created" }]
+      };
+    });
+  }
+  /**
+   * Claim a pending task for a member. Moves status to `"claimed"`.
+   */
+  async claimTask(taskId, memberId) {
+    return this.retryOnConflict(async () => {
+      const id = requireNonEmpty(memberId, "member ID");
+      const task = await this.requireTask(taskId);
+      if (task.status !== "pending") {
+        throw new Error(`Task "${taskId}" is not claimable (status: ${task.status})`);
+      }
+      if (task.memberId && task.memberId !== id) {
+        throw new Error(`Task "${taskId}" is assigned to ${task.memberId}, not ${id}`);
+      }
+      const ts = now();
+      return this.store.putTask({
+        ...task,
+        memberId: id,
+        status: "claimed",
+        claimedAt: ts,
+        updatedAt: ts
+      });
+    });
+  }
+  /**
+   * Claim the next available pending task for a member.
+   * Prefers tasks already assigned to this member, then unassigned tasks.
+   */
+  async claimNextTask(memberId) {
+    const id = requireNonEmpty(memberId, "member ID");
+    const pending = await this.store.listTasks({ status: "pending" });
+    const next = pending.find((t) => t.memberId === id) ?? pending.find((t) => !t.memberId);
+    if (!next) return void 0;
+    return this.claimTask(next.id, id);
+  }
+  /**
+   * Mark a claimed task as running with a run reference.
+   */
+  async startTask(taskId, runId) {
+    return this.retryOnConflict(async () => {
+      const task = await this.requireTask(taskId);
+      if (task.status !== "claimed") {
+        throw new Error(`Task "${taskId}" must be claimed before starting (status: ${task.status})`);
+      }
+      return this.store.putTask({
+        ...task,
+        status: "running",
+        runId,
+        updatedAt: now()
+      });
+    });
+  }
+  /**
+   * Complete a running task with a result.
+   * Cascades: blocked dependents may become pending or cancelled.
+   */
+  async completeTask(taskId, result) {
+    return this.retryOnConflict(async () => {
+      const task = await this.requireTask(taskId);
+      const completed = {
+        ...task,
+        status: "completed",
+        result,
+        error: void 0,
+        updatedAt: now()
+      };
+      const stored = await this.store.putTask(completed);
+      const cascaded = await this.refreshDependents();
+      return {
+        task: stored,
+        transitions: [{ task: stored, reason: "completed", previous: task.status }, ...cascaded]
+      };
+    });
+  }
+  /**
+   * Fail a running task.
+   * Cascades: blocked dependents may be cancelled.
+   */
+  async failTask(taskId, error) {
+    return this.retryOnConflict(async () => {
+      const task = await this.requireTask(taskId);
+      const failed = {
+        ...task,
+        status: "failed",
+        result: void 0,
+        error: requireNonEmpty(error, "error"),
+        updatedAt: now()
+      };
+      const stored = await this.store.putTask(failed);
+      const cascaded = await this.refreshDependents();
+      return {
+        task: stored,
+        transitions: [{ task: stored, reason: "failed", previous: task.status }, ...cascaded]
+      };
+    });
+  }
+  /**
+   * Abort a claimed or running task without cascading dependency failure.
+   *
+   * Downstream tasks remain blocked so the host can retry or replace the
+   * aborted prerequisite explicitly.
+   */
+  async abortTask(taskId, reason) {
+    return this.retryOnConflict(async () => {
+      const task = await this.requireTask(taskId);
+      if (isTerminal(task.status)) {
+        throw new Error(`Task "${taskId}" is already terminal (status: ${task.status})`);
+      }
+      const aborted = {
+        ...task,
+        status: "aborted",
+        result: void 0,
+        error: reason?.trim() || task.error,
+        updatedAt: now()
+      };
+      const stored = await this.store.putTask(aborted);
+      return {
+        task: stored,
+        transitions: [{ task: stored, reason: "aborted", previous: task.status }]
+      };
+    });
+  }
+  /**
+   * Cancel a task (at any non-terminal status).
+   * Cascades: blocked dependents may be cancelled.
+   */
+  async cancelTask(taskId, reason) {
+    return this.retryOnConflict(async () => {
+      const task = await this.requireTask(taskId);
+      if (isTerminal(task.status)) {
+        throw new Error(`Task "${taskId}" is already terminal (status: ${task.status})`);
+      }
+      const cancelled = {
+        ...task,
+        status: "cancelled",
+        result: void 0,
+        error: reason?.trim() || task.error,
+        updatedAt: now()
+      };
+      const stored = await this.store.putTask(cancelled);
+      const cascaded = await this.refreshDependents();
+      return {
+        task: stored,
+        transitions: [{ task: stored, reason: "cancelled", previous: task.status }, ...cascaded]
+      };
+    });
+  }
+  /**
+   * Re-evaluate all blocked tasks against current dependency state.
+   * Called automatically after complete/fail/cancel, but can also
+   * be called manually for batch operations.
+   */
+  async refreshDependents() {
+    return this.retryOnConflict(async () => {
+      const allTasks = await this.store.listTasks();
+      const lookup = new Map(allTasks.map((t) => [t.id, t]));
+      const transitions = [];
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const task of lookup.values()) {
+          if (task.status !== "blocked") continue;
+          const resolved = resolveDependencyStatus(task, lookup);
+          if (resolved.status === task.status) continue;
+          const updated = {
+            ...task,
+            status: resolved.status,
+            updatedAt: now(),
+            error: resolved.failedDeps.length > 0 ? `Dependency failed: ${resolved.failedDeps.join(", ")}` : void 0
+          };
+          const stored = await this.store.putTask(updated);
+          lookup.set(stored.id, stored);
+          changed = true;
+          transitions.push({
+            task: stored,
+            reason: resolved.failedDeps.length > 0 ? "blocked-dependency-failed" : "unblocked",
+            previous: task.status
+          });
+        }
+      }
+      return transitions;
+    });
+  }
+  // ── Internal ───────────────────────────────────────────────────────
+  async requireTask(taskId) {
+    const task = await this.store.getTask(taskId);
+    if (!task) throw new Error(`Unknown task: ${taskId}`);
+    return task;
+  }
+  async retryOnConflict(op) {
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await op();
+      } catch (error) {
+        if (error instanceof TaskConflictError && attempt + 1 < TASK_CONFLICT_MAX_RETRIES) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+};
+
+// src/team/mailbox.ts
+import { randomUUID } from "crypto";
+function clone2(value) {
+  return structuredClone(value);
+}
+function requireNonEmpty2(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error(`${label} must not be empty`);
+  return trimmed;
+}
+function matchesKind(msg, kind) {
+  if (!kind) return true;
+  const list = Array.isArray(kind) ? kind : [kind];
+  return list.includes(msg.kind);
+}
+var InMemoryMailboxStore = class {
+  messages = [];
+  async append(message) {
+    const copy = clone2(message);
+    this.messages.push(copy);
+    return clone2(copy);
+  }
+  async list(filter) {
+    let msgs = this.messages;
+    if (filter?.teamId) msgs = msgs.filter((m) => m.teamId === filter.teamId);
+    if (filter?.from) msgs = msgs.filter((m) => m.from === filter.from);
+    if (filter?.to) msgs = msgs.filter((m) => m.to === filter.to);
+    if (filter?.taskId) msgs = msgs.filter((m) => m.taskId === filter.taskId);
+    if (filter?.kind) msgs = msgs.filter((m) => matchesKind(m, filter.kind));
+    const sorted = msgs.map(clone2).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    if (filter?.limit !== void 0) {
+      const n = Math.max(0, Math.floor(filter.limit));
+      return sorted.slice(Math.max(0, sorted.length - n));
+    }
+    return sorted;
+  }
+};
+var Mailbox = class {
+  store;
+  subscribers = /* @__PURE__ */ new Set();
+  createId;
+  constructor(options) {
+    this.store = options?.store ?? new InMemoryMailboxStore();
+    this.createId = options?.createId ?? (() => randomUUID());
+  }
+  async start() {
+    await this.store.start?.();
+  }
+  async stop() {
+    await this.store.stop?.();
+  }
+  /**
+   * Send a message. Notifies subscribers after persistence.
+   */
+  async send(input) {
+    const to = input.to?.trim() || void 0;
+    const message = {
+      id: input.id?.trim() || this.createId(),
+      teamId: requireNonEmpty2(input.teamId, "teamId"),
+      from: requireNonEmpty2(input.from, "from"),
+      to,
+      kind: input.kind ?? (to ? "direct" : "broadcast"),
+      body: requireNonEmpty2(input.body, "body"),
+      payload: input.payload ? clone2(input.payload) : void 0,
+      taskId: input.taskId?.trim() || void 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: input.metadata ? { ...input.metadata } : void 0
+    };
+    const stored = await this.store.append(message);
+    if (this.subscribers.size > 0) {
+      const delivered = clone2(stored);
+      await Promise.allSettled(
+        [...this.subscribers].map((sub) => sub(clone2(delivered)))
+      );
+    }
+    return clone2(stored);
+  }
+  /**
+   * List messages matching the filter.
+   */
+  async list(filter) {
+    return this.store.list(filter);
+  }
+  /**
+   * Subscribe to new messages. Returns an unsubscribe function.
+   */
+  subscribe(subscriber) {
+    this.subscribers.add(subscriber);
+    return () => {
+      this.subscribers.delete(subscriber);
+    };
+  }
+};
+
+// src/team/coordinator/coordinator.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/team/permissions.ts
+function matchesRule(rule, memberId, toolName, args, ctx) {
+  if (!matchApprovalPattern(rule.tool, toolName)) return false;
+  if (rule.members && !rule.members.includes(memberId)) return false;
+  if (!rule.pattern) return true;
+  const patterns = ctx.permissionPatterns ? ctx.permissionPatterns(args) : extractApprovalPatterns(toolName, args);
+  return patterns.some((pattern) => matchApprovalPattern(rule.pattern, pattern));
+}
+function teamPermissionPolicy(config) {
+  const rules = config.rules ?? [];
+  return {
+    name: `team-permission:${config.memberId}`,
+    async beforeToolCall(tool, args, ctx) {
+      if (resolveCapability(ctx.toolCapabilities?.readOnly, args, false)) {
+        return { action: "allow" };
+      }
+      for (const rule of rules) {
+        if (matchesRule(rule, config.memberId, tool, args, ctx)) {
+          if (rule.action === "deny") {
+            return {
+              action: "deny",
+              reason: rule.reason ?? `Denied by team policy for "${config.memberId}"`
+            };
+          }
+          return { action: "allow" };
+        }
+      }
+      if (config.forwardApproval) {
+        return config.forwardApproval(config.memberId, tool, args, ctx);
+      }
+      return { action: "allow" };
+    }
+  };
+}
+
+// src/team/execution.ts
+function isTerminalStatus(status) {
+  return status === "completed" || status === "aborted" || status === "failed" || status === "cancelled";
+}
+function isQueuedMessageForMember(message, memberId) {
+  if (message.kind === "system") {
+    return false;
+  }
+  if (message.kind === "broadcast") {
+    return true;
+  }
+  return message.to === memberId;
+}
+async function collectPendingMessages(ctx, runtime) {
+  const messages = await ctx.mailbox.list({
+    teamId: ctx.teamId,
+    kind: ["direct", "broadcast"]
+  });
+  const relevant = messages.filter((message) => isQueuedMessageForMember(message, runtime.member.id));
+  if (!runtime.lastDeliveredMessageAt || !runtime.lastDeliveredMessageId) {
+    return relevant;
+  }
+  const pending = [];
+  let cursorReached = false;
+  for (const message of relevant) {
+    if (cursorReached) {
+      pending.push(message);
+      continue;
+    }
+    if (message.createdAt < runtime.lastDeliveredMessageAt) {
+      continue;
+    }
+    if (message.createdAt > runtime.lastDeliveredMessageAt) {
+      cursorReached = true;
+      pending.push(message);
+      continue;
+    }
+    if (message.id === runtime.lastDeliveredMessageId) {
+      cursorReached = true;
+    }
+  }
+  return pending;
+}
+async function claimAndExecute(ctx, runtime) {
+  if (runtime.member.status !== "idle") return void 0;
+  const claimed = await ctx.taskBoard.claimNextTask(runtime.member.id);
+  if (!claimed) return void 0;
+  await ctx.updateMemberStatus(runtime.member.id, "busy", claimed.id);
+  await ctx.emitTransitions([{ task: claimed, reason: "claimed", previous: "pending" }]);
+  const started = await ctx.taskBoard.startTask(claimed.id, ctx.createId());
+  await ctx.emit({
+    type: "team-task-transition",
+    teamId: ctx.teamId,
+    taskId: started.id,
+    previous: claimed.status,
+    current: "running",
+    reason: "started"
+  });
+  const pendingMessages = await collectPendingMessages(ctx, runtime);
+  if (pendingMessages.length > 0) {
+    const latest = pendingMessages[pendingMessages.length - 1];
+    runtime.lastDeliveredMessageAt = latest.createdAt;
+    runtime.lastDeliveredMessageId = latest.id;
+  }
+  const prompt = buildTaskPrompt(runtime.role, started, pendingMessages);
+  runtime.taskAbort = new AbortController();
+  runtime.taskStartedAt = Date.now();
+  runtime.activeRun = executeTask(ctx, runtime, started, prompt).catch((err) => {
+    ctx.log?.(`[${runtime.member.id}] executeTask unhandled error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+  return started;
+}
+async function prepareTaskForExternalExecution(ctx, runtime, taskId, runId) {
+  if (ctx.taskDispatchMode !== "external") {
+    throw new Error('External task preparation requires taskDispatchMode="external"');
+  }
+  if (runtime.member.status !== "idle") return void 0;
+  const task = await ctx.taskBoard.getTask(taskId);
+  if (!task || task.memberId !== runtime.member.id || task.status !== "pending") {
+    return void 0;
+  }
+  const claimed = await ctx.taskBoard.claimTask(taskId, runtime.member.id);
+  await ctx.updateMemberStatus(runtime.member.id, "busy", claimed.id);
+  await ctx.emitTransitions([{ task: claimed, reason: "claimed", previous: "pending" }]);
+  const started = await ctx.taskBoard.startTask(claimed.id, runId);
+  await ctx.emit({
+    type: "team-task-transition",
+    teamId: ctx.teamId,
+    taskId: started.id,
+    previous: claimed.status,
+    current: "running",
+    reason: "started"
+  });
+  const pendingMessages = await collectPendingMessages(ctx, runtime);
+  if (pendingMessages.length > 0) {
+    const latest = pendingMessages[pendingMessages.length - 1];
+    runtime.lastDeliveredMessageAt = latest.createdAt;
+    runtime.lastDeliveredMessageId = latest.id;
+  }
+  runtime.taskStartedAt = Date.now();
+  return {
+    task: started,
+    memberId: runtime.member.id,
+    memberRole: runtime.role.name,
+    sessionId: runtime.member.sessionId,
+    prompt: buildTaskPrompt(runtime.role, started, pendingMessages)
+  };
+}
+async function executeTask(ctx, runtime, task, prompt) {
+  try {
+    const result = ctx.taskExecutor ? await ctx.taskExecutor({
+      runtime,
+      task,
+      prompt,
+      parentSessionId: ctx.leadSessionId,
+      abort: runtime.taskAbort?.signal
+    }) : await runtime.agent.run({
+      parentSessionId: ctx.leadSessionId,
+      message: prompt,
+      title: task.title,
+      abort: runtime.taskAbort?.signal
+    });
+    const taskResult = {
+      response: result.response,
+      usage: result.usage,
+      toolCalls: result.toolCalls
+    };
+    await completePreparedTask(ctx, runtime, task.id, taskResult);
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    const wasAborted = runtime.taskAbort?.signal.aborted;
+    try {
+      if (wasAborted) {
+        await abortPreparedTask(
+          ctx,
+          runtime,
+          task.id,
+          String(runtime.taskAbort?.signal.reason ?? error)
+        );
+        return;
+      }
+      await failPreparedTask(ctx, runtime, task.id, error);
+    } catch (inner) {
+      ctx.log?.(`[${runtime.member.id}] task finalization error: ${inner instanceof Error ? inner.message : String(inner)}`);
+    }
+  } finally {
+    try {
+      await finalizePreparedTask(ctx, runtime, true);
+    } catch (cleanupErr) {
+      ctx.log?.(`[${runtime.member.id}] finalizePreparedTask error: ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}`);
+      runtime.activeRun = void 0;
+      runtime.taskAbort = void 0;
+      runtime.taskStartedAt = void 0;
+      try {
+        await ctx.updateMemberStatus(runtime.member.id, "idle", void 0);
+      } catch {
+        runtime.member.status = "idle";
+      }
+    }
+  }
+}
+async function completePreparedTask(ctx, runtime, taskId, taskResult) {
+  const latest = await beginTaskFinalization(ctx, runtime, taskId);
+  if (!latest) return void 0;
+  runtime.stats.tasksCompleted += 1;
+  runtime.stats.totalToolCalls += taskResult.toolCalls?.length ?? 0;
+  if (taskResult.usage) {
+    runtime.stats.totalTokens = {
+      inputTokens: (runtime.stats.totalTokens.inputTokens ?? 0) + (taskResult.usage.inputTokens ?? 0),
+      outputTokens: (runtime.stats.totalTokens.outputTokens ?? 0) + (taskResult.usage.outputTokens ?? 0),
+      totalTokens: (runtime.stats.totalTokens.totalTokens ?? 0) + (taskResult.usage.totalTokens ?? 0)
+    };
+  }
+  const { task, transitions } = await ctx.taskBoard.completeTask(taskId, taskResult);
+  await ctx.emit({
+    type: "team-task-completed",
+    teamId: ctx.teamId,
+    taskId,
+    memberId: runtime.member.id,
+    result: taskResult
+  });
+  await ctx.emitTransitions(transitions);
+  return { task, transitions };
+}
+async function failPreparedTask(ctx, runtime, taskId, error) {
+  const latest = await beginTaskFinalization(ctx, runtime, taskId);
+  if (!latest) return void 0;
+  runtime.stats.tasksFailed += 1;
+  const { task, transitions } = await ctx.taskBoard.failTask(taskId, error);
+  await ctx.emit({
+    type: "team-task-failed",
+    teamId: ctx.teamId,
+    taskId,
+    memberId: runtime.member.id,
+    error
+  });
+  await ctx.emitTransitions(transitions);
+  return { task, transitions };
+}
+async function abortPreparedTask(ctx, runtime, taskId, reason) {
+  const latest = await beginTaskFinalization(ctx, runtime, taskId);
+  if (!latest) return void 0;
+  const { task, transitions } = await ctx.taskBoard.abortTask(taskId, reason);
+  await ctx.emit({
+    type: "team-task-aborted",
+    teamId: ctx.teamId,
+    taskId,
+    memberId: runtime.member.id,
+    reason
+  });
+  await ctx.emitTransitions(transitions);
+  return { task, transitions };
+}
+function buildTaskPrompt(role, task, pendingMessages = []) {
+  const queuedMessages = pendingMessages.length > 0 ? "\n\nTeam messages to consider before you start:\n" + pendingMessages.map((message) => `- [${message.kind}] ${message.from}: ${message.body}`).join("\n") : "";
+  return `You are the "${role.name}" specialist.
+
+Role: ${role.description}
+
+Task: ${task.title}
+
+` + task.prompt + queuedMessages;
+}
+async function beginTaskFinalization(ctx, runtime, taskId) {
+  const duration = runtime.taskStartedAt ? Date.now() - runtime.taskStartedAt : 0;
+  runtime.stats.totalDurationMs += duration;
+  runtime.stats.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+  const latest = await ctx.taskBoard.getTask(taskId);
+  if (!latest || isTerminalStatus(latest.status)) {
+    return void 0;
+  }
+  return latest;
+}
+async function finalizePreparedTask(ctx, runtime, clearAbortController) {
+  runtime.activeRun = void 0;
+  if (clearAbortController) {
+    runtime.taskAbort = void 0;
+  }
+  runtime.taskStartedAt = void 0;
+  if (runtime.stopRequested || runtime.member.status === "shutting-down") {
+    await ctx.updateMemberStatus(runtime.member.id, "offline", void 0);
+    return;
+  }
+  await ctx.updateMemberStatus(runtime.member.id, "idle", void 0);
+  if (ctx.taskDispatchMode === "manual") {
+    await ctx.dispatchReady();
+  }
+}
+
+// src/team/work-loop.ts
+async function runWorkLoop(ctx, runtime) {
+  while (!runtime.stopRequested && ctx.started) {
+    if (runtime.member.status === "idle") {
+      if (ctx.beforeIteration) {
+        try {
+          const skip = await ctx.beforeIteration(
+            runtime.member.id,
+            runtime.agent,
+            runtime.stats
+          );
+          if (skip === false) {
+            await sleep(ctx.pollIntervalMs);
+            continue;
+          }
+        } catch (err) {
+          ctx.log?.(`[${runtime.member.id}] beforeIteration error: ${err instanceof Error ? err.message : String(err)}`);
+          await sleep(ctx.pollIntervalMs);
+          continue;
+        }
+      }
+      const task = await tryClaimAndExecute(ctx, runtime);
+      if (task) {
+        if (runtime.activeRun) {
+          try {
+            await runtime.activeRun;
+          } catch (err) {
+            ctx.log?.(`[${runtime.member.id}] work-loop: task error \u2014 ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        continue;
+      }
+    }
+    if (runtime.member.status === "busy" && runtime.activeRun) {
+      try {
+        await runtime.activeRun;
+      } catch (err) {
+        ctx.log?.(`[${runtime.member.id}] work-loop: active run error \u2014 ${err instanceof Error ? err.message : String(err)}`);
+      }
+      continue;
+    }
+    await sleep(ctx.pollIntervalMs);
+  }
+  if (runtime.member.status !== "offline") {
+    await ctx.updateMemberStatus(runtime.member.id, "offline", void 0);
+  }
+}
+async function tryClaimAndExecute(ctx, runtime) {
+  return claimAndExecute(ctx, runtime);
+}
+
+// src/team/shutdown.ts
+async function requestShutdown(ctx, memberId, reason, timeoutMs) {
+  const runtime = ctx.members.get(memberId);
+  if (!runtime) {
+    throw new Error(
+      `Unknown member: "${memberId}". Registered: ${[...ctx.members.keys()].join(", ")}`
+    );
+  }
+  if (runtime.member.status === "offline") return true;
+  if (runtime.member.status === "shutting-down") {
+    return waitForOffline(runtime, timeoutMs);
+  }
+  const requestId = ctx.createId();
+  runtime.pendingShutdownId = requestId;
+  runtime.stopRequested = true;
+  await ctx.emit({
+    type: "team-shutdown-requested",
+    teamId: ctx.teamId,
+    memberId,
+    requestId,
+    reason
+  });
+  await ctx.mailbox.send({
+    teamId: ctx.teamId,
+    from: "coordinator",
+    to: memberId,
+    kind: "system",
+    body: reason ?? "Shutdown requested by coordinator.",
+    payload: {
+      kind: "shutdown-request",
+      requestId,
+      reason
+    },
+    metadata: { payloadKind: "shutdown-request", requestId }
+  });
+  if (runtime.member.status === "idle") {
+    await ctx.updateMemberStatus(memberId, "offline", void 0);
+    await emitShutdownResolved(ctx, memberId, requestId, true);
+    runtime.pendingShutdownId = void 0;
+    return true;
+  }
+  await ctx.updateMemberStatus(memberId, "shutting-down", runtime.member.activeTaskId);
+  const accepted = await waitForOffline(runtime, timeoutMs);
+  await emitShutdownResolved(ctx, memberId, requestId, accepted);
+  runtime.pendingShutdownId = void 0;
+  return accepted;
+}
+async function shutdownAll(ctx, reason, timeoutMs) {
+  const ids = [...ctx.members.keys()].filter((id) => {
+    const rt = ctx.members.get(id);
+    return rt && rt.member.status !== "offline";
+  });
+  await Promise.all(
+    ids.map((id) => requestShutdown(ctx, id, reason, timeoutMs))
+  );
+}
+async function waitForOffline(runtime, timeoutMs) {
+  const deadline = timeoutMs !== void 0 ? Date.now() + timeoutMs : void 0;
+  while (runtime.member.status !== "offline") {
+    if (deadline && Date.now() >= deadline) return false;
+    await sleep(100);
+  }
+  return true;
+}
+async function emitShutdownResolved(ctx, memberId, requestId, accepted) {
+  await ctx.emit({
+    type: "team-shutdown-resolved",
+    teamId: ctx.teamId,
+    memberId,
+    requestId,
+    accepted
+  });
+}
+
+// src/team/coordinator/turn.ts
+import { z } from "zod";
+
+// src/team/coordinator/policy.ts
+var coordinatorToolDescriptions = {
+  assignTask(memberList) {
+    return `Assign a task to a teammate. The teammate receives ONLY the prompt you provide \u2014 include all necessary context, file paths, and instructions. Available teammates: ${memberList}`;
+  },
+  sendMessage: "Send guidance to a teammate. If they're working, the message is injected immediately. If they're idle, it's queued for their next task.",
+  abortTask: "Abort a running task without cascading to blocked dependents. The teammate returns to idle and can be assigned new work. Use this when a task is taking the wrong approach or should be restarted."
+};
+function buildCoordinatorSystemPrompt(members) {
+  const roster = members.map(
+    (member) => `- **${member.id}** (${member.role}): ${member.description ?? "General purpose agent"}`
+  ).join("\n");
+  return "You are the team coordinator. Your job is to break down tasks, delegate work to your teammates, synthesize their results, and communicate the final answer to the user.\n\n## Your Teammates\n\n" + roster + "\n\n## How It Works\n\n1. You receive the user's request.\n2. Decide what work to delegate. Use `assignTask` to give each teammate a focused, self-contained task.\n3. After teammates finish, you'll receive their results as [Task Notification] messages.\n4. Teammates may also send you [Worker Report] messages with mid-task findings or blockers.\n5. Based on results and reports, you may assign follow-up tasks, send guidance via `sendMessage`, or produce your final answer.\n\n## Guidelines\n\n- **Answer directly** when the question is simple and doesn't need tool use.\n- **Delegate** when work requires reading files, writing code, running tests, or exploration.\n- **After assigning tasks, briefly state what you assigned and end your response.** Do not wait for, predict, or fabricate task results \u2014 they will arrive as [Task Notification] messages.\n- **Write self-contained prompts.** Each teammate sees ONLY their task prompt. Include specific file paths, line numbers, and all context they need. Never say 'based on the research' \u2014 include the actual findings.\n- **Parallelize** independent tasks. Assign multiple teammates in one turn when their work doesn't depend on each other.\n- **Use dependencies** when tasks must run in order. Pass `dependsOn: [taskId]` to block a task until its prerequisites complete. Use the task IDs returned by previous assignTask calls.\n- **Serialize** dependent tasks. Wait for research results before assigning implementation work, or use `dependsOn` to chain them.\n- **Synthesize before acting.** When research results come back, read and understand them before directing follow-up work.\n- **Do not repeat completed work.** If a teammate has already completed a task and their result answers the need, synthesize it into your response instead of assigning the same task again.\n- **Only reassign after completion when there is a concrete gap.** If the result is missing, failed, clearly incomplete, or you need a different follow-up phase, explain that gap and assign a narrower next task.\n- **Teammates retain context.** If you assign the same teammate a second task, they remember their prior work. Use this for research-then-implement flows on the same teammate.\n- **On failure:** Review the error. If context is useful, assign the same teammate again. If the approach was wrong, assign a different teammate or try a new strategy.\n\n## Workflow Phases\n\nFor complex tasks, follow this pattern:\n1. **Research** \u2014 Explore the codebase, read files, understand the problem\n2. **Synthesize** \u2014 Read research results and form a concrete plan with specific files and changes\n3. **Implement** \u2014 Direct implementation with exact instructions including file paths and code\n4. **Verify** \u2014 Run tests, check the output, confirm the changes work\n\nWhen you have received all results and have nothing more to delegate, respond with your final comprehensive answer to the user.";
+}
+function formatCoordinatorTaskNotifications(notifications) {
+  if (notifications.length === 0) return "";
+  return notifications.map((notification) => {
+    let resultText = `Status: ${notification.status}`;
+    if (notification.status === "completed" && notification.result?.response) {
+      resultText = notification.result.response;
+    } else if (notification.status === "failed") {
+      resultText = `Error: ${notification.error ?? "Unknown error"}`;
+    } else if (notification.status === "aborted") {
+      resultText = `Aborted${notification.error ? `: ${notification.error}` : ""}`;
+    } else if (notification.error) {
+      resultText = notification.error;
+    }
+    return `[Task Notification]
+Task: ${notification.taskId} (${notification.memberId})
+Title: ${notification.title}
+Status: ${notification.status}
+Result:
+${resultText}`;
+  }).join("\n\n---\n\n");
+}
+function formatCoordinatorWorkerReports(reports) {
+  if (reports.length === 0) return "";
+  return reports.map(
+    (report) => `[Worker Report]
+From: ${report.memberId}
+${report.taskId ? `Task: ${report.taskId}
+` : ""}Message:
+${report.message}`
+  ).join("\n\n---\n\n");
+}
+function formatCoordinatorRoundMessage(notifications, reports) {
+  const parts = [];
+  const taskText = formatCoordinatorTaskNotifications(notifications);
+  const reportText = formatCoordinatorWorkerReports(reports);
+  if (taskText) parts.push(taskText);
+  if (reportText) parts.push(reportText);
+  return parts.join("\n\n---\n\n");
+}
+
+// src/team/coordinator/turn.ts
+var ASK_COORDINATOR_TIMEOUT_MS = 9e4;
+function createAskCoordinatorTool(deps) {
+  const { memberId, teamId, runtime, mailbox } = deps;
+  return Tool.define("askCoordinator", {
+    description: "Ask the coordinator a question and wait for a response before continuing. Use this ONLY when you genuinely need guidance to proceed \u2014 for example, you've hit an ambiguity, discovered something that changes the task scope, or need clarification on requirements. Do NOT use this for progress updates; just continue working and report results when you finish.",
+    capabilities: { readOnly: true },
+    parameters: z.object({
+      question: z.string().describe(
+        "Your question for the coordinator \u2014 be specific about what you need to know"
+      )
+    }),
+    execute: async (params) => {
+      await mailbox.send({
+        teamId,
+        from: memberId,
+        to: "coordinator",
+        kind: "direct",
+        body: params.question,
+        payload: { kind: "worker-report" },
+        metadata: { payloadKind: "worker-report" }
+      });
+      const response = await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          runtime.pendingAskResolve = void 0;
+          resolve("");
+        }, ASK_COORDINATOR_TIMEOUT_MS);
+        runtime.pendingAskResolve = (msg) => {
+          clearTimeout(timeout);
+          runtime.pendingAskResolve = void 0;
+          resolve(msg);
+        };
+      });
+      if (!response) {
+        return {
+          title: "No response from coordinator",
+          output: "The coordinator hasn't responded yet. Use your best judgment and continue working on the task.",
+          metadata: { truncated: false }
+        };
+      }
+      return {
+        title: "Coordinator response",
+        output: response,
+        metadata: { truncated: false }
+      };
+    }
+  });
+}
+function isAbortError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") return true;
+  if (err instanceof Error && err.name === "AbortError") return true;
+  if (err instanceof Error && err.message?.includes("aborted")) return true;
+  return false;
+}
+async function* raceAbort(source, signal) {
+  if (signal.aborted) return;
+  const aborted = new Promise((resolve) => {
+    signal.addEventListener(
+      "abort",
+      () => resolve({ done: true, value: void 0 }),
+      { once: true }
+    );
+  });
+  try {
+    while (true) {
+      const result = await Promise.race([source.next(), aborted]);
+      if (result.done) return;
+      yield result.value;
+    }
+  } finally {
+    const cleanup = source.return(void 0);
+    await Promise.race([
+      cleanup,
+      new Promise((resolve) => setTimeout(resolve, 5e3))
+    ]).catch(() => {
+    });
+  }
+}
+function formatNotification(notification) {
+  switch (notification.kind) {
+    case "worker-report":
+      return `[Worker Report]
+From: ${notification.memberId}
+${notification.taskId ? `Task: ${notification.taskId}
+` : ""}Message:
+${notification.body}`;
+    case "task-result":
+      return `[Task Notification]
+Task: ${notification.taskId ?? "unknown"} (${notification.memberId})
+Title: ${notification.title}
+Status: ${notification.status ?? "unknown"}
+${notification.body}`;
+    default:
+      return `[Coordinator Notification]
+From: ${notification.memberId}
+Kind: ${notification.kind}
+${notification.body}`;
+  }
+}
+function formatCoordinatorInboxBatch(items) {
+  return items.map(
+    (item) => item.kind === "user-message" ? item.body : formatNotification(item.notification ?? {
+      id: item.id,
+      teamId: "",
+      memberId: "unknown",
+      kind: "worker-report",
+      priority: "immediate",
+      title: "Notification",
+      body: item.body,
+      createdAt: item.createdAt
+    })
+  ).join("\n\n---\n\n");
+}
+function createCoordinatorTools(coordinator) {
+  const memberIds = [...coordinator.members.keys()];
+  const memberList = memberIds.join(", ");
+  const assignTask = Tool.define("assignTask", {
+    description: coordinatorToolDescriptions.assignTask(memberList),
+    parameters: z.object({
+      memberId: z.string().describe("Teammate ID to assign the task to"),
+      title: z.string().describe("Short task title (2-6 words)"),
+      prompt: z.string().describe(
+        "Self-contained task prompt with all context the teammate needs"
+      ),
+      dependsOn: z.array(z.string()).optional().describe(
+        "Task IDs this task must wait for before starting."
+      )
+    }),
+    capabilities: { readOnly: true },
+    execute: async (params) => {
+      const state = coordinator.getActiveCoordinatorTurnState();
+      const task = await coordinator.queue({
+        memberId: params.memberId,
+        title: params.title,
+        prompt: params.prompt,
+        dependsOn: params.dependsOn
+      });
+      state.actions.assigned.push({
+        taskId: task.id,
+        memberId: params.memberId,
+        title: params.title
+      });
+      return {
+        title: `Assigned to ${params.memberId}`,
+        output: `Task ${task.id} assigned to ${params.memberId}: "${params.title}"`,
+        metadata: {}
+      };
+    }
+  });
+  const sendMessage = Tool.define("sendMessage", {
+    description: coordinatorToolDescriptions.sendMessage,
+    parameters: z.object({
+      memberId: z.string().describe("Teammate ID to message"),
+      message: z.string().describe("Guidance or instructions to send")
+    }),
+    capabilities: { readOnly: true },
+    execute: async (params) => {
+      const state = coordinator.getActiveCoordinatorTurnState();
+      await coordinator.guide(params.memberId, params.message);
+      state.actions.sentMessages.push({ memberId: params.memberId });
+      return {
+        title: `Messaged ${params.memberId}`,
+        output: `Message sent to ${params.memberId}`,
+        metadata: {}
+      };
+    }
+  });
+  const abortTask = Tool.define("abortTask", {
+    description: coordinatorToolDescriptions.abortTask,
+    parameters: z.object({
+      taskId: z.string().describe("ID of the task to abort"),
+      reason: z.string().optional().describe("Why the task is being aborted")
+    }),
+    capabilities: { readOnly: true },
+    execute: async (params) => {
+      const state = coordinator.getActiveCoordinatorTurnState();
+      await coordinator.abort(params.taskId, params.reason);
+      state.actions.abortedTaskIds.push(params.taskId);
+      return {
+        title: "Task aborted",
+        output: `Task ${params.taskId} aborted${params.reason ? `: ${params.reason}` : ""}`,
+        metadata: {}
+      };
+    }
+  });
+  return [assignTask, sendMessage, abortTask];
+}
+function createCoordinatorAgent(coordinator) {
+  return coordinator.lead.fork({
+    name: "coordinator",
+    systemPrompt: buildCoordinatorSystemPrompt(
+      [...coordinator.members.values()].map((runtime) => ({
+        id: runtime.member.id,
+        role: runtime.role.name,
+        description: runtime.role.description
+      }))
+    ),
+    tools: createCoordinatorTools(coordinator),
+    reasoningLevel: "off",
+    maxSteps: 1
+  });
+}
+async function runCoordinatorTurn(coordinator, agent, sessionId, message, options) {
+  const log = options?.onLog ?? (() => {
+  });
+  const onEvent = options?.onEvent;
+  const onStatus = options?.onStatus;
+  const roundAbort = new AbortController();
+  const state = coordinator.beginCoordinatorTurnState();
+  let response = "";
+  let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  const toolCalls = [];
+  let hasDelegated = false;
+  let inactivityTimer = null;
+  const INACTIVITY_MS_NORMAL = 9e4;
+  const INACTIVITY_MS_DELEGATED = 15e3;
+  const clearTimers = () => {
+    if (inactivityTimer) clearTimeout(inactivityTimer);
+    inactivityTimer = null;
+  };
+  const resetInactivityTimer = () => {
+    if (inactivityTimer) clearTimeout(inactivityTimer);
+    const ms = hasDelegated ? INACTIVITY_MS_DELEGATED : INACTIVITY_MS_NORMAL;
+    inactivityTimer = setTimeout(() => {
+      log(`Aborting coordinator stream after ${ms / 1e3}s inactivity (delegated=${hasDelegated})`);
+      roundAbort.abort();
+    }, ms);
+  };
+  coordinator.attachCoordinatorTurn(agent, sessionId);
+  coordinator.setCoordinatorTurnOpen(true);
+  resetInactivityTimer();
+  log(`runCoordinatorTurn: start (msg=${message.length}ch)`);
+  try {
+    onStatus?.({
+      phase: "running",
+      message: "Coordinator processing inbox...",
+      pendingInboxCount: coordinator.getCoordinatorInboxSize(),
+      activeTaskCount: await coordinator.getActiveTaskCount()
+    });
+    for await (const event of raceAbort(agent.chat(sessionId, message, { abort: roundAbort.signal }), roundAbort.signal)) {
+      resetInactivityTimer();
+      if (event.type !== "text-delta" && event.type !== "reasoning-delta") {
+        const detail = event.type === "tool-start" ? ` ${event.toolName}` : event.type === "tool-result" ? ` ${event.toolName}` : event.type === "error" ? ` ${event.error?.message?.slice(0, 80)}` : event.type === "status" ? ` ${event.status}` : "";
+        log(`stream: ${event.type}${detail}`);
+      }
+      const isMaxStepsNoise = event.type === "status" && event.status === "error" && hasDelegated || event.type === "error" && event.error?.message?.includes("Maximum steps");
+      const isAbortNoise = roundAbort.signal.aborted && (event.type === "status" && event.status === "error" || event.type === "error" && isAbortError(event.error));
+      if (onEvent && !isMaxStepsNoise && !isAbortNoise) {
+        onEvent(event);
+      }
+      if (event.type === "tool-start") {
+        const isCoordinatorTool = ["assignTask", "sendMessage", "abortTask"].includes(event.toolName);
+        if (isCoordinatorTool) {
+          hasDelegated = true;
+          resetInactivityTimer();
+        }
+      }
+      switch (event.type) {
+        case "text-delta":
+          response += event.text;
+          break;
+        case "tool-result":
+          toolCalls.push({ name: event.toolName, result: event.result });
+          break;
+        case "step-finish":
+          if (event.usage) usage = event.usage;
+          break;
+        case "complete":
+          if (event.usage) usage = event.usage;
+          if (event.output !== void 0) response = event.output;
+          break;
+        case "error":
+          if (event.error?.message?.includes("Maximum steps")) {
+            break;
+          }
+          if (isAbortError(event.error) && roundAbort.signal.aborted) {
+            break;
+          }
+          throw event.error;
+      }
+    }
+  } catch (error) {
+    if (!(isAbortError(error) && roundAbort.signal.aborted)) {
+      log(`runCoordinatorTurn: error \u2014 ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+    log(`runCoordinatorTurn: aborted (expected)`);
+  } finally {
+    clearTimers();
+    coordinator.setCoordinatorTurnOpen(false);
+    if (roundAbort.signal.aborted) {
+      agent.clearSessionLock(sessionId);
+    }
+    coordinator.endCoordinatorTurnState();
+  }
+  log(`runCoordinatorTurn: done \u2014 delegated=${hasDelegated} response=${response.length}ch assigned=${state.actions.assigned.length} msgs=${state.actions.sentMessages.length}`);
+  return {
+    response,
+    usage,
+    toolCalls,
+    delegated: hasDelegated,
+    actions: {
+      assigned: [...state.actions.assigned],
+      sentMessages: [...state.actions.sentMessages],
+      abortedTaskIds: [...state.actions.abortedTaskIds]
+    }
+  };
+}
+
+// src/team/notifications.ts
+function formatTaskBody(task, fallbackStatus, fallbackDetail) {
+  const title = task?.title || "Untitled task";
+  const detail = task?.status === "completed" && task.result?.response ? task.result.response : task?.status === "failed" ? task.error ?? fallbackDetail : task?.status === "aborted" ? task.error ?? fallbackDetail : task?.status === "cancelled" ? task.error ?? fallbackDetail : fallbackDetail;
+  return `Title: ${title}
+Status: ${task?.status ?? fallbackStatus}
+Result:
+${detail}`;
+}
+function buildWorkerReportNotification(event) {
+  if (event.message.payload?.kind !== "worker-report") {
+    return null;
+  }
+  return {
+    type: "team-notification",
+    teamId: event.teamId,
+    notification: {
+      id: `worker-report:${event.message.id}`,
+      teamId: event.teamId,
+      memberId: event.message.from,
+      kind: "worker-report",
+      priority: "immediate",
+      title: "Worker report",
+      body: event.message.body,
+      createdAt: event.message.createdAt,
+      taskId: event.message.taskId
+    }
+  };
+}
+function buildPermissionForwardedNotification(event) {
+  return {
+    type: "team-notification",
+    teamId: event.teamId,
+    notification: {
+      id: `permission-forwarded:${event.requestId}`,
+      teamId: event.teamId,
+      memberId: event.memberId,
+      kind: "permission-forwarded",
+      priority: "immediate",
+      title: `Permission request \xB7 ${event.tool}`,
+      body: `Requested approval for "${event.tool}".`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function buildPermissionResolvedNotification(event) {
+  return {
+    type: "team-notification",
+    teamId: event.teamId,
+    notification: {
+      id: `permission-resolved:${event.requestId}:${event.decision}`,
+      teamId: event.teamId,
+      memberId: event.memberId,
+      kind: "permission-resolved",
+      priority: "immediate",
+      title: `Permission ${event.decision}`,
+      body: event.decision === "allow" ? "Coordinator approved the pending tool request." : "Coordinator denied the pending tool request.",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function buildShutdownRequestedNotification(event) {
+  return {
+    type: "team-notification",
+    teamId: event.teamId,
+    notification: {
+      id: `shutdown-requested:${event.requestId}`,
+      teamId: event.teamId,
+      memberId: event.memberId,
+      kind: "shutdown-requested",
+      priority: "immediate",
+      title: "Shutdown requested",
+      body: event.reason ? `Shutdown requested. Reason: ${event.reason}` : "Shutdown requested.",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function buildShutdownResolvedNotification(event) {
+  return {
+    type: "team-notification",
+    teamId: event.teamId,
+    notification: {
+      id: `shutdown-resolved:${event.requestId}:${event.accepted ? "accepted" : "rejected"}`,
+      teamId: event.teamId,
+      memberId: event.memberId,
+      kind: "shutdown-resolved",
+      priority: "immediate",
+      title: event.accepted ? "Shutdown accepted" : "Shutdown deferred",
+      body: event.accepted ? "Member accepted shutdown and went offline." : "Member did not complete shutdown within the requested window.",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function buildTaskResultNotification(event, resolveTask) {
+  const task = await resolveTask(event.taskId);
+  const detail = event.type === "team-task-completed" ? event.result.response : event.type === "team-task-failed" ? event.error : event.reason ?? "Aborted";
+  const status = event.type === "team-task-completed" ? "completed" : event.type === "team-task-failed" ? "failed" : "aborted";
+  const priority = status === "completed" ? "deferred" : "immediate";
+  const memberId = event.memberId ?? task?.memberId ?? "worker";
+  return {
+    type: "team-notification",
+    teamId: event.teamId,
+    notification: {
+      id: `task-result:${event.taskId}:${status}:${task?.updatedAt ?? "unknown"}`,
+      teamId: event.teamId,
+      memberId,
+      kind: "task-result",
+      priority,
+      title: task?.title ?? "Task result",
+      body: formatTaskBody(task, status, detail),
+      createdAt: task?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      taskId: event.taskId,
+      status
+    }
+  };
+}
+async function buildCoordinatorNotificationEvent(event, resolveTask) {
+  switch (event.type) {
+    case "team-task-completed":
+    case "team-task-failed":
+    case "team-task-aborted":
+      return buildTaskResultNotification(event, resolveTask);
+    case "team-message":
+      return buildWorkerReportNotification(event);
+    case "team-permission-forwarded":
+      return buildPermissionForwardedNotification(event);
+    case "team-permission-resolved":
+      return buildPermissionResolvedNotification(event);
+    case "team-shutdown-requested":
+      return buildShutdownRequestedNotification(event);
+    case "team-shutdown-resolved":
+      return buildShutdownResolvedNotification(event);
+    default:
+      return null;
+  }
+}
+
+// src/team/coordinator/inbox.ts
+var MAX_CONSECUTIVE_TURNS = 20;
+var MAX_AUTONOMOUS_TURNS = 30;
+function enqueueInboxItem(ctx, item) {
+  ctx.coordinatorInbox.push(item);
+  ctx.publishCoordinatorStatus({
+    pendingInboxCount: ctx.coordinatorInbox.length
+  });
+}
+function enqueueNotification(ctx, notification) {
+  if (notification.kind !== "worker-report" && notification.kind !== "task-result" && notification.kind !== "shutdown-requested" && notification.kind !== "shutdown-resolved") {
+    return;
+  }
+  enqueueInboxItem(ctx, {
+    id: notification.id,
+    kind: "notification",
+    createdAt: notification.createdAt,
+    body: notification.body,
+    notification
+  });
+}
+function scheduleProcessing(ctx) {
+  if (!ctx.started) {
+    return;
+  }
+  if (ctx.coordinatorProcessing) {
+    ctx.coordinatorReschedule = true;
+    return;
+  }
+  ctx.coordinatorProcessing = true;
+  void processInbox(ctx).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.log(`processInbox: unhandled error \u2014 ${msg}`);
+    ctx.coordinatorProcessing = false;
+    ctx.publishCoordinatorStatus({
+      phase: "error",
+      message: msg,
+      activeTaskCount: 0
+    });
+    ctx.publishCoordinatorEvent({
+      type: "error",
+      error: err instanceof Error ? err : new Error(msg)
+    });
+  });
+}
+async function processInbox(ctx) {
+  try {
+    const agent = ctx.ensureCoordinatorAgent();
+    const sessionId = ctx.getCoordinatorSessionId();
+    let consecutiveTurns = 0;
+    ctx.log(`processInbox: starting drain (inbox=${ctx.coordinatorInbox.length}, processing=${ctx.coordinatorProcessing})`);
+    while (ctx.started) {
+      if (consecutiveTurns >= MAX_CONSECUTIVE_TURNS) {
+        ctx.log(`Inbox processor yielding after ${consecutiveTurns} consecutive turns`);
+        break;
+      }
+      const batch = ctx.coordinatorInbox.splice(0);
+      ctx.publishCoordinatorStatus({
+        pendingInboxCount: ctx.coordinatorInbox.length
+      });
+      if (batch.length === 0) {
+        const activeTaskCount = await ctx.getActiveTaskCount();
+        const nextPhase = activeTaskCount > 0 ? "waiting" : "ready";
+        ctx.log(`processInbox: empty batch \u2192 phase=${nextPhase} (activeTasks=${activeTaskCount})`);
+        ctx.publishCoordinatorStatus({
+          phase: nextPhase,
+          message: activeTaskCount > 0 ? `Waiting on ${activeTaskCount} task${activeTaskCount === 1 ? "" : "s"}` : "Ready",
+          activeTaskCount
+        });
+        break;
+      }
+      ctx.log(`processInbox: batch of ${batch.length} items (${batch.map((i) => i.kind).join(", ")})`);
+      const hasUser = batch.some((item) => item.kind === "user-message");
+      const hasNotification = batch.some((item) => item.kind === "notification");
+      let turnBatch;
+      if (hasUser && hasNotification) {
+        turnBatch = batch.filter((item) => item.kind === "user-message");
+        const deferred = batch.filter((item) => item.kind !== "user-message");
+        ctx.coordinatorInbox.unshift(...deferred);
+        ctx.publishCoordinatorStatus({
+          pendingInboxCount: ctx.coordinatorInbox.length
+        });
+      } else {
+        turnBatch = batch;
+      }
+      if (hasUser) {
+        ctx.autonomousTurnCount = 0;
+      } else {
+        ctx.autonomousTurnCount += 1;
+        if (ctx.autonomousTurnCount > MAX_AUTONOMOUS_TURNS) {
+          ctx.log(
+            `Coordinator yielding after ${ctx.autonomousTurnCount} autonomous turns \u2014 waiting for user guidance`
+          );
+          ctx.coordinatorInbox.unshift(...turnBatch);
+          const activeTaskCount = await ctx.getActiveTaskCount();
+          ctx.publishCoordinatorStatus({
+            phase: "ready",
+            message: "Autonomous turn limit reached \u2014 send a message to continue",
+            activeTaskCount,
+            pendingInboxCount: ctx.coordinatorInbox.length
+          });
+          break;
+        }
+      }
+      const firstUser = turnBatch.find((item) => item.kind === "user-message");
+      const activeTaskCountBeforeTurn = await ctx.getActiveTaskCount();
+      ctx.publishCoordinatorStatus({
+        phase: "running",
+        message: firstUser ? "Coordinator processing user guidance..." : "Coordinator processing team updates...",
+        activeTaskCount: activeTaskCountBeforeTurn,
+        pendingInboxCount: ctx.coordinatorInbox.length
+      });
+      const message = formatCoordinatorInboxBatch(turnBatch);
+      ctx.log(`processInbox: running coordinator turn #${consecutiveTurns + 1} (autonomousTurns=${ctx.autonomousTurnCount})`);
+      let turnAssignedCount = 0;
+      let turnResponseLength = 0;
+      try {
+        const turn = await runCoordinatorTurn(
+          // The turn runner expects the full TeamCoordinator for turn
+          // state management. The InboxContext is a superset at runtime
+          // since the coordinator implements it.
+          ctx,
+          agent,
+          sessionId,
+          message,
+          {
+            onEvent: (event) => ctx.publishCoordinatorEvent(event),
+            onStatus: (status) => ctx.publishCoordinatorStatus(status),
+            onLog: (msg) => ctx.log(msg)
+          }
+        );
+        const completionEntries = [];
+        for (const item of turnBatch) {
+          const taskId = item.notification?.kind === "task-result" ? item.notification.taskId : void 0;
+          if (!taskId) {
+            continue;
+          }
+          const task = await ctx.getTask(taskId);
+          if (!task) {
+            continue;
+          }
+          completionEntries.push({
+            task,
+            result: task.result
+          });
+        }
+        const reportEntries = turnBatch.filter((item) => item.notification?.kind === "worker-report").map((item) => ({
+          messageId: item.notification?.id ?? item.id,
+          memberId: item.notification?.memberId ?? "worker",
+          taskId: item.notification?.taskId,
+          createdAt: item.notification?.createdAt ?? item.createdAt,
+          message: item.notification?.body ?? item.body
+        }));
+        ctx.coordinatorRoundNumber += 1;
+        await ctx.emit({
+          type: "team-coordinator-round",
+          teamId: ctx.teamId,
+          roundNumber: ctx.coordinatorRoundNumber,
+          assigned: turn.actions.assigned,
+          messaged: turn.actions.sentMessages,
+          stopped: turn.actions.abortedTaskIds,
+          completions: completionEntries,
+          reports: reportEntries,
+          response: turn.response,
+          usage: turn.usage
+        });
+        ctx.publishCoordinatorEvent({
+          type: "complete",
+          output: turn.response,
+          usage: turn.usage
+        });
+        turnAssignedCount = turn.actions.assigned.length;
+        turnResponseLength = turn.response.length;
+        consecutiveTurns += 1;
+      } catch (error) {
+        const messageText = error instanceof Error ? error.message : String(error);
+        ctx.log(`processInbox: turn error \u2014 ${messageText}`);
+        ctx.publishCoordinatorStatus({
+          phase: "error",
+          message: messageText,
+          activeTaskCount: await ctx.getActiveTaskCount()
+        });
+        ctx.publishCoordinatorEvent({
+          type: "error",
+          error: error instanceof Error ? error : new Error(messageText)
+        });
+        break;
+      }
+      const activeTaskCountAfterTurn = await ctx.getActiveTaskCount();
+      const afterPhase = activeTaskCountAfterTurn > 0 ? "waiting" : "ready";
+      ctx.log(`processInbox: turn done \u2014 assigned=${turnAssignedCount} response=${turnResponseLength > 0 ? turnResponseLength + "ch" : "(empty)"} \u2192 phase=${afterPhase} (activeTasks=${activeTaskCountAfterTurn}, inbox=${ctx.coordinatorInbox.length})`);
+      ctx.publishCoordinatorStatus({
+        phase: afterPhase,
+        message: activeTaskCountAfterTurn > 0 ? `Waiting on ${activeTaskCountAfterTurn} task${activeTaskCountAfterTurn === 1 ? "" : "s"}` : "Ready",
+        activeTaskCount: activeTaskCountAfterTurn,
+        pendingInboxCount: ctx.coordinatorInbox.length
+      });
+      if (ctx.coordinatorInbox.length === 0 && activeTaskCountAfterTurn > 0) {
+        ctx.log(`processInbox: yielding \u2014 waiting on ${activeTaskCountAfterTurn} task(s)`);
+        break;
+      }
+    }
+  } finally {
+    ctx.coordinatorProcessing = false;
+    if (ctx.coordinatorReschedule || ctx.coordinatorInbox.length > 0) {
+      ctx.log(`processInbox: rescheduling (reschedule=${ctx.coordinatorReschedule}, inbox=${ctx.coordinatorInbox.length})`);
+      ctx.coordinatorReschedule = false;
+      ctx.scheduleCoordinatorProcessing();
+    } else {
+      ctx.log(`processInbox: idle \u2014 resolving waiters`);
+      ctx.resolveCoordinatorIdleWaiters();
+    }
+  }
+}
+
+// src/team/coordinator/planning.ts
+async function planTasks(coordinator, prompt, memberIds) {
+  const targets = memberIds ? memberIds.map((id) => {
+    const rt = coordinator.members.get(id);
+    if (!rt) {
+      throw new Error(
+        `Unknown member: "${id}". Registered: ${[...coordinator.members.keys()].join(", ")}`
+      );
+    }
+    return rt;
+  }) : [...coordinator.members.values()];
+  if (targets.length === 0) {
+    throw new Error("No members available for planning");
+  }
+  const memberDescriptions = targets.map(
+    (rt) => `- ${rt.member.id} (${rt.role.name}): ${rt.role.description ?? "General purpose"}`
+  ).join("\n");
+  const planningPrompt = "You are the team lead. Decompose the following task into targeted sub-tasks for your teammates.\n\nAvailable teammates:\n" + memberDescriptions + "\n\nUser request:\n" + prompt + `
+
+Create a focused, self-contained task prompt for each relevant teammate. Each prompt must include all necessary context \u2014 teammates cannot see the original request or each other's tasks.
+
+Respond with ONLY a JSON array (no markdown fences, no explanation):
+[
+  { "memberId": "id", "title": "short title", "prompt": "detailed self-contained prompt" }
+]
+
+You may omit teammates that are not needed for this task.`;
+  const result = await coordinator.lead.send(coordinator.leadSessionId, planningPrompt);
+  const tasks = parsePlanResponse(result.response, prompt, targets);
+  await coordinator.emit({
+    type: "team-plan-created",
+    teamId: coordinator.teamId,
+    tasks
+  });
+  return { tasks, usage: result.usage };
+}
+async function planAndExecuteTasks(coordinator, prompt, memberIds) {
+  const teamPlan = await planTasks(coordinator, prompt, memberIds);
+  const planIndexToTaskId = /* @__PURE__ */ new Map();
+  const tasks = [];
+  for (let i = 0; i < teamPlan.tasks.length; i++) {
+    const planned = teamPlan.tasks[i];
+    let resolvedDeps;
+    if (planned.dependsOn && planned.dependsOn.length > 0) {
+      resolvedDeps = [];
+      for (const dep of planned.dependsOn) {
+        const idx = Number(dep);
+        if (!Number.isNaN(idx) && planIndexToTaskId.has(idx)) {
+          resolvedDeps.push(planIndexToTaskId.get(idx));
+          continue;
+        }
+        const match = tasks.find(
+          (t) => t.title === dep || t.memberId === dep || t.id === dep
+        );
+        if (match) {
+          resolvedDeps.push(match.id);
+        }
+      }
+      if (resolvedDeps.length === 0) resolvedDeps = void 0;
+    }
+    const task = await coordinator.queue({
+      memberId: planned.memberId,
+      title: planned.title,
+      prompt: planned.prompt,
+      dependsOn: resolvedDeps
+    });
+    tasks.push(task);
+    planIndexToTaskId.set(i, task.id);
+  }
+  return { plan: teamPlan, tasks };
+}
+function parsePlanResponse(response, originalPrompt, targets) {
+  const validIds = new Set(targets.map((t) => t.member.id));
+  let jsonStr = response.trim();
+  const codeBlockMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlockMatch) {
+    jsonStr = codeBlockMatch[1].trim();
+  }
+  const arrayMatch = jsonStr.match(/\[[\s\S]*\]/);
+  if (arrayMatch) {
+    jsonStr = arrayMatch[0];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    return targets.map((rt) => ({
+      memberId: rt.member.id,
+      title: `task:${rt.role.name}`,
+      prompt: originalPrompt
+    }));
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    return targets.map((rt) => ({
+      memberId: rt.member.id,
+      title: `task:${rt.role.name}`,
+      prompt: originalPrompt
+    }));
+  }
+  const tasks = [];
+  for (const item of parsed) {
+    if (typeof item !== "object" || item === null) continue;
+    const obj = item;
+    const memberId = obj.memberId;
+    const prompt = obj.prompt;
+    if (typeof memberId !== "string" || typeof prompt !== "string") continue;
+    if (!validIds.has(memberId)) continue;
+    tasks.push({
+      memberId,
+      title: typeof obj.title === "string" ? obj.title : `task:${memberId}`,
+      prompt,
+      dependsOn: Array.isArray(obj.dependsOn) ? obj.dependsOn.filter((d) => typeof d === "string") : void 0
+    });
+  }
+  if (tasks.length === 0) {
+    return targets.map((rt) => ({
+      memberId: rt.member.id,
+      title: `task:${rt.role.name}`,
+      prompt: originalPrompt
+    }));
+  }
+  return tasks;
+}
+
+// src/team/coordinator/synthesis.ts
+async function synthesizeResults(coordinator, originalPrompt, taskIds) {
+  const allTasks = await coordinator.taskBoard.listTasks();
+  const terminal = (taskIds ? allTasks.filter((t) => taskIds.includes(t.id)) : allTasks).filter(
+    (t) => t.status === "completed" || t.status === "aborted" || t.status === "failed" || t.status === "cancelled"
+  );
+  if (terminal.length === 0) {
+    throw new Error("No completed tasks to synthesize");
+  }
+  const sections = terminal.map((task) => {
+    const runtime = coordinator.members.get(task.memberId ?? "");
+    const name = runtime?.role.name ?? task.memberId ?? "unassigned";
+    if (task.status === "completed" && task.result) {
+      return `## ${name}
+${task.result.response}`;
+    }
+    return `## ${name}
+Status: ${task.status}
+${task.error ?? "No result."}`;
+  });
+  const synthesisPrompt = `You are the team lead. Synthesize the findings from your teammates into one clear, comprehensive answer.
+
+Original task:
+${originalPrompt}
+
+Teammate results:
+
+` + sections.join("\n\n");
+  const result = await coordinator.lead.send(coordinator.leadSessionId, synthesisPrompt);
+  await coordinator.emit({
+    type: "team-synthesis",
+    teamId: coordinator.teamId,
+    response: result.response
+  });
+  return result;
+}
+
+// src/team/coordinator/coordinator.ts
+var TeamCoordinator = class {
+  teamId;
+  /** @internal */
+  lead;
+  /** @internal */
+  leadSessionId;
+  /** @internal */
+  createId;
+  roles = /* @__PURE__ */ new Map();
+  /** @internal */
+  members = /* @__PURE__ */ new Map();
+  /** @internal */
+  taskBoard;
+  /** @internal */
+  mailbox;
+  onEvent;
+  eventListeners = /* @__PURE__ */ new Set();
+  signal;
+  /** @internal */
+  workLoopEnabled;
+  /** @internal */
+  taskDispatchMode;
+  /** @internal */
+  pollIntervalMs;
+  /** @internal */
+  onPermissionRequest;
+  /** @internal */
+  beforeIteration;
+  /** @internal */
+  sharedPermissions;
+  /** @internal */
+  taskExecutor;
+  externalTaskControl;
+  /** @internal */
+  started = false;
+  onLog;
+  logger;
+  activeCoordinatorTurn;
+  mailboxUnsubscribe;
+  coordinatorAgent;
+  coordinatorSessionId;
+  /** @internal */
+  coordinatorInbox = [];
+  /** @internal */
+  coordinatorProcessing = false;
+  /** @internal */
+  coordinatorReschedule = false;
+  coordinatorStatus = {
+    phase: "ready",
+    message: "Ready",
+    pendingInboxCount: 0,
+    activeTaskCount: 0
+  };
+  coordinatorEventListeners = /* @__PURE__ */ new Set();
+  coordinatorStatusListeners = /* @__PURE__ */ new Set();
+  coordinatorIdleResolvers = [];
+  /** @internal */
+  coordinatorRoundNumber = 0;
+  coordinatorRunSequence = 0;
+  coordinatorTurnState = null;
+  /** @internal Structured log output — writes to both logger and onLog when provided. */
+  log(msg) {
+    const tagged = `[team] ${msg}`;
+    this.logger?.info(tagged);
+    this.onLog?.(tagged);
+  }
+  async dispatchEvent(event) {
+    if (this.signal) {
+      try {
+        this.signal.emit(event);
+      } catch {
+      }
+    }
+    for (const listener of this.eventListeners) {
+      try {
+        await listener(event);
+      } catch {
+      }
+    }
+    if (this.onEvent) {
+      try {
+        await this.onEvent(event);
+      } catch {
+      }
+    }
+  }
+  subscribeTeamEvents(listener) {
+    this.eventListeners.add(listener);
+    return () => {
+      this.eventListeners.delete(listener);
+    };
+  }
+  /** @internal */
+  publishCoordinatorEvent(event) {
+    for (const listener of this.coordinatorEventListeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  publishCoordinatorStatus(status) {
+    this.coordinatorStatus = {
+      ...this.coordinatorStatus,
+      ...status,
+      pendingInboxCount: status.pendingInboxCount ?? this.coordinatorInbox.length
+    };
+    for (const listener of this.coordinatorStatusListeners) {
+      try {
+        listener({ ...this.coordinatorStatus });
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  resolveCoordinatorIdleWaiters() {
+    if (this.coordinatorProcessing) {
+      return;
+    }
+    if (this.coordinatorInbox.length > 0) {
+      return;
+    }
+    if (this.coordinatorStatus.phase !== "ready" && this.coordinatorStatus.phase !== "error") {
+      return;
+    }
+    const resolvers = this.coordinatorIdleResolvers.splice(0);
+    for (const resolve of resolvers) {
+      resolve();
+    }
+  }
+  constructor(config) {
+    this.lead = config.lead;
+    this.leadSessionId = config.leadSessionId;
+    this.teamId = config.teamId?.trim() || `team-${randomUUID2().slice(0, 8)}`;
+    this.createId = config.createId ?? (() => randomUUID2());
+    this.onEvent = config.onEvent;
+    this.signal = config.signal;
+    this.taskDispatchMode = config.taskDispatchMode ?? (config.workLoopEnabled ?? false ? "workloop" : "manual");
+    this.workLoopEnabled = this.taskDispatchMode === "workloop";
+    this.pollIntervalMs = config.pollIntervalMs ?? 500;
+    this.onPermissionRequest = config.onPermissionRequest;
+    this.beforeIteration = config.beforeIteration;
+    this.sharedPermissions = config.sharedPermissions;
+    this.taskExecutor = config.taskExecutor;
+    this.externalTaskControl = config.externalTaskControl;
+    this.onLog = config.onLog;
+    this.logger = config.logger?.child("team");
+    this.taskBoard = new TaskBoard(
+      config.taskBoardStore ?? new InMemoryTaskBoardStore()
+    );
+    this.mailbox = new Mailbox({
+      store: config.mailboxStore ?? new InMemoryMailboxStore(),
+      createId: this.createId
+    });
+    for (const role of config.roles) {
+      this.roles.set(role.name, { ...role });
+    }
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────
+  async start() {
+    if (this.started) return;
+    await this.taskBoard.start();
+    try {
+      await this.mailbox.start();
+    } catch (error) {
+      await this.taskBoard.stop().catch(() => {
+      });
+      throw error;
+    }
+    this.started = true;
+    this.mailboxUnsubscribe = this.mailbox.subscribe((message) => {
+      if (message.teamId !== this.teamId) {
+        return;
+      }
+      if (message.to !== "coordinator") {
+        return;
+      }
+      if (message.payload?.kind !== "worker-report") {
+        return;
+      }
+      void this.emit({
+        type: "team-message",
+        teamId: this.teamId,
+        message
+      });
+    });
+    this.log(`Started (${this.members.size} member(s), ${this.roles.size} role(s))`);
+    this.publishCoordinatorStatus({
+      phase: "ready",
+      message: "Ready",
+      pendingInboxCount: 0,
+      activeTaskCount: 0
+    });
+    if (this.workLoopEnabled) {
+      for (const runtime of this.members.values()) {
+        if (!runtime.workLoop) {
+          runtime.stopRequested = false;
+          runtime.workLoop = runWorkLoop(this, runtime).catch((err) => {
+            this.log(`[${runtime.member.id}] work-loop crashed: ${err instanceof Error ? err.message : String(err)}`);
+          });
+        }
+      }
+    }
+    await this.emit({
+      type: "team-started",
+      teamId: this.teamId,
+      memberCount: this.members.size
+    });
+  }
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    this.log("Stopping...");
+    this.mailboxUnsubscribe?.();
+    this.mailboxUnsubscribe = void 0;
+    this.detachCoordinatorTurn();
+    this.coordinatorInbox = [];
+    this.coordinatorReschedule = false;
+    this.coordinatorProcessing = false;
+    this.autonomousTurnCount = 0;
+    this.endCoordinatorTurnState();
+    for (const runtime of this.members.values()) {
+      runtime.stopRequested = true;
+    }
+    const promises = [];
+    for (const m of this.members.values()) {
+      if (m.workLoop) promises.push(m.workLoop);
+      if (m.activeRun) promises.push(m.activeRun);
+    }
+    await Promise.allSettled(promises);
+    for (const runtime of this.members.values()) {
+      runtime.workLoop = void 0;
+    }
+    let firstError;
+    try {
+      await this.mailbox.stop();
+    } catch (error) {
+      firstError = error;
+    }
+    try {
+      await this.taskBoard.stop();
+    } catch (error) {
+      if (!firstError) {
+        firstError = error;
+      }
+    }
+    await this.emit({
+      type: "team-stopped",
+      teamId: this.teamId
+    });
+    this.publishCoordinatorStatus({
+      phase: "ready",
+      message: "Stopped",
+      pendingInboxCount: 0,
+      activeTaskCount: 0
+    });
+    this.resolveCoordinatorIdleWaiters();
+    if (firstError) {
+      throw firstError;
+    }
+  }
+  // ── Member registration ────────────────────────────────────────────
+  /**
+   * Register a team member from a role.
+   * Forks the lead agent with the role's specialization.
+   */
+  async register(roleName, memberId = roleName) {
+    const id = memberId.trim();
+    if (!id) throw new Error("Member ID must not be empty");
+    const existing = this.members.get(id);
+    if (existing) return { ...existing.member };
+    const role = this.roles.get(roleName);
+    if (!role) {
+      throw new Error(
+        `Unknown role: "${roleName}". Available: ${[...this.roles.keys()].join(", ")}`
+      );
+    }
+    const permissionRules = (this.sharedPermissions ?? []).map((rule) => ({
+      tool: rule.tool,
+      pattern: rule.pattern,
+      action: "allow"
+    }));
+    const inheritedMiddleware = [...this.lead.getMiddlewareRunner().getMiddleware()];
+    const inheritedApprovalMiddleware = inheritedMiddleware.filter((mw) => mw.name === "approval");
+    const needsTeamPermissionPolicy = permissionRules.length > 0 || inheritedApprovalMiddleware.length > 0 || Boolean(this.onPermissionRequest);
+    const memberMiddleware = needsTeamPermissionPolicy ? [
+      ...inheritedMiddleware.filter(
+        (mw) => mw.name !== "approval" && !mw.name.startsWith("team-permission:")
+      ),
+      ...role.additionalMiddleware ?? [],
+      teamPermissionPolicy({
+        memberId: id,
+        rules: permissionRules,
+        forwardApproval: async (_memberId, tool, args, ctx) => {
+          if (this.onPermissionRequest) {
+            return this.createPermissionForwarder(id)(_memberId, tool, args, ctx);
+          }
+          let currentArgs = args;
+          for (const approval of inheritedApprovalMiddleware) {
+            if (!approval.beforeToolCall) continue;
+            const decision = await approval.beforeToolCall(tool, currentArgs, ctx);
+            if (decision.action === "deny") {
+              return decision;
+            }
+            if (decision.args !== void 0) {
+              currentArgs = decision.args;
+            }
+          }
+          return currentArgs === args ? { action: "allow" } : { action: "allow", args: currentArgs };
+        }
+      })
+    ] : void 0;
+    const agent = this.lead.fork({
+      name: id,
+      profile: role.profile,
+      systemPrompt: role.systemPrompt,
+      model: role.model,
+      maxSteps: role.maxSteps,
+      ...memberMiddleware ? { middleware: memberMiddleware } : { additionalMiddleware: role.additionalMiddleware }
+    });
+    for (const tool of role.additionalTools ?? []) {
+      agent.addTool(tool);
+    }
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionId = `team:${this.teamId}:${id}`;
+    const member = {
+      id,
+      role: role.name,
+      description: role.description,
+      sessionId,
+      status: "idle",
+      createdAt: ts,
+      updatedAt: ts
+    };
+    await this.taskBoard.putMember(member);
+    const stats = {
+      tasksCompleted: 0,
+      tasksFailed: 0,
+      totalTokens: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+      totalToolCalls: 0,
+      totalDurationMs: 0,
+      lastActivityAt: ts
+    };
+    this.members.set(id, {
+      member,
+      role,
+      agent,
+      stopRequested: false,
+      stats
+    });
+    this.log(`Registered member @${id} (role: ${role.name}${role.description ? `, ${role.description}` : ""})`);
+    await this.emit({
+      type: "team-member-registered",
+      teamId: this.teamId,
+      member: { ...member }
+    });
+    const runtime = this.members.get(id);
+    agent.addTool(createAskCoordinatorTool({
+      memberId: id,
+      teamId: this.teamId,
+      runtime,
+      mailbox: this.mailbox
+    }));
+    if (this.taskDispatchMode === "workloop" && this.started) {
+      runtime.workLoop = runWorkLoop(this, runtime).catch((err) => {
+        this.log(`[${id}] work-loop crashed: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    }
+    return { ...member };
+  }
+  /**
+   * Register all roles (or a subset) as team members.
+   */
+  async registerAll(roleNames) {
+    const names = roleNames?.length ? roleNames : [...this.roles.keys()];
+    return Promise.all(names.map((name) => this.register(name)));
+  }
+  /**
+   * List available role names.
+   */
+  listRoles() {
+    return [...this.roles.keys()];
+  }
+  // ── Task management ────────────────────────────────────────────────
+  /**
+   * Queue a task. If dependencies are met and a member is idle,
+   * the task is dispatched immediately.
+   */
+  async queue(input) {
+    if (input.memberId) {
+      this.requireMember(input.memberId);
+    }
+    const { task, transitions } = await this.taskBoard.createTask({
+      id: this.createId(),
+      memberId: input.memberId,
+      title: input.title,
+      prompt: input.prompt,
+      dependsOn: input.dependsOn
+    });
+    this.log(`Queued task "${input.title}" \u2192 ${input.memberId ?? "unassigned"}${input.dependsOn?.length ? ` (depends on ${input.dependsOn.length} task(s))` : ""}`);
+    await this.emitTransitions(transitions);
+    if (this.taskDispatchMode === "manual") {
+      await this.dispatchReady();
+    }
+    return await this.taskBoard.getTask(task.id) ?? task;
+  }
+  /**
+   * Dispatch all pending tasks to idle members.
+   * Called automatically after queue/complete/fail/cancel.
+   */
+  async dispatchReady() {
+    if (this.taskDispatchMode === "external") {
+      return [];
+    }
+    const dispatched = [];
+    const members = await this.taskBoard.listMembers();
+    for (const member of members) {
+      if (member.status !== "idle") continue;
+      const runtime = this.members.get(member.id);
+      if (!runtime) continue;
+      const task = await claimAndExecute(this, runtime);
+      if (task) dispatched.push(task);
+    }
+    return dispatched;
+  }
+  /**
+   * Wait for a specific task to reach a terminal state.
+   */
+  async waitForTask(taskId, timeoutMs) {
+    const deadline = timeoutMs !== void 0 ? Date.now() + timeoutMs : void 0;
+    while (true) {
+      const task = await this.taskBoard.getTask(taskId);
+      if (!task) throw new Error(`Unknown task: ${taskId}`);
+      if (task.status === "completed" || task.status === "aborted" || task.status === "failed" || task.status === "cancelled") {
+        return { task, result: task.result };
+      }
+      if (deadline && Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for task "${taskId}"`);
+      }
+      await sleep(100);
+    }
+  }
+  /**
+   * Wait for all tasks to reach terminal states.
+   */
+  async waitForAll(timeoutMs) {
+    const deadline = timeoutMs !== void 0 ? Date.now() + timeoutMs : void 0;
+    const tasks = await this.taskBoard.listTasks();
+    const results = [];
+    for (const task of tasks) {
+      const remaining = deadline ? Math.max(1, deadline - Date.now()) : void 0;
+      results.push(await this.waitForTask(task.id, remaining));
+    }
+    return results;
+  }
+  /**
+   * Cancel a task. If it's running, the task's AbortController fires.
+   * Cascades to dependent tasks.
+   */
+  async cancel(taskId, reason) {
+    const { task, transitions } = await this.taskBoard.cancelTask(taskId, reason);
+    await this.emitTransitions(transitions);
+    if (task.memberId) {
+      const runtime = this.members.get(task.memberId);
+      if (runtime?.taskAbort && runtime.member.activeTaskId === taskId) {
+        runtime.taskAbort.abort(reason ?? "Task cancelled");
+      } else if (runtime && runtime.member.activeTaskId === taskId && !runtime.activeRun) {
+        await this.finalizeExternallyTerminatedTask(runtime);
+      }
+    }
+    if (this.taskDispatchMode === "manual") {
+      await this.dispatchReady();
+    }
+    return task;
+  }
+  /**
+   * Abort a running task. The member returns to idle and can pick up
+   * new work. Unlike `cancel()`, abort preserves downstream tasks by
+   * leaving them blocked on the aborted prerequisite.
+   */
+  async abort(taskId, reason) {
+    const task = await this.taskBoard.getTask(taskId);
+    if (!task) throw new Error(`Unknown task: ${taskId}`);
+    if (task.status !== "running" && task.status !== "claimed") {
+      throw new Error(`Cannot abort task in "${task.status}" state`);
+    }
+    const { task: aborted, transitions } = await this.taskBoard.abortTask(taskId, reason);
+    await this.emitTransitions(transitions);
+    await this.emit({
+      type: "team-task-aborted",
+      teamId: this.teamId,
+      taskId,
+      memberId: aborted.memberId ?? "unassigned",
+      reason
+    });
+    if (aborted.memberId) {
+      const runtime = this.members.get(aborted.memberId);
+      if (runtime?.taskAbort) {
+        runtime.taskAbort.abort(reason ?? "Aborted by coordinator");
+      } else if (runtime && this.externalTaskControl?.abortTask) {
+        void this.externalTaskControl.abortTask({
+          task: aborted,
+          runtime,
+          reason
+        }).catch((err) => {
+          this.log(`External abortTask failed for task ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      } else if (runtime && runtime.member.activeTaskId === taskId && !runtime.activeRun) {
+        await this.finalizeExternallyTerminatedTask(runtime);
+      }
+    }
+  }
+  // ── Communication ──────────────────────────────────────────────────
+  /**
+   * Send a guidance message to a running member via intervention.
+   * If the member is idle, queues a direct-message task instead.
+   */
+  async guide(memberId, message) {
+    const runtime = this.requireMember(memberId);
+    const body = message.trim();
+    if (!body) throw new Error("Message must not be empty");
+    const record = await this.mailbox.send({
+      teamId: this.teamId,
+      from: "coordinator",
+      to: memberId,
+      kind: "direct",
+      body,
+      payload: { kind: "guidance", taskId: runtime.member.activeTaskId },
+      taskId: runtime.member.activeTaskId,
+      metadata: { payloadKind: "guidance" }
+    });
+    await this.emit({
+      type: "team-message",
+      teamId: this.teamId,
+      message: record
+    });
+    if (runtime.member.status === "busy" && runtime.member.activeTaskId) {
+      runtime.lastDeliveredMessageAt = record.createdAt;
+      runtime.lastDeliveredMessageId = record.id;
+      if (runtime.pendingAskResolve) {
+        runtime.pendingAskResolve(body);
+        this.log(`Ask response \u2192 @${memberId}: "${body.length > 80 ? body.slice(0, 80) + "\u2026" : body}"`);
+        return;
+      }
+      if (runtime.taskAbort || this.taskDispatchMode !== "external") {
+        runtime.agent.intervene(body);
+      } else if (this.externalTaskControl?.guideTask) {
+        const activeTask = await this.taskBoard.getTask(runtime.member.activeTaskId);
+        if (activeTask) {
+          void this.externalTaskControl.guideTask({
+            task: activeTask,
+            runtime,
+            message: body
+          }).catch((err) => {
+            this.log(`External guideTask failed for @${memberId}: ${err instanceof Error ? err.message : String(err)}`);
+          });
+        }
+      }
+      this.log(`Intervention \u2192 @${memberId}: "${body.length > 80 ? body.slice(0, 80) + "\u2026" : body}"`);
+      return;
+    }
+    if (this.taskDispatchMode === "manual") {
+      runtime.lastDeliveredMessageAt = record.createdAt;
+      runtime.lastDeliveredMessageId = record.id;
+      await this.queue({
+        memberId,
+        title: "guidance",
+        prompt: body
+      });
+    }
+  }
+  /**
+   * Broadcast a message to all members. Active members receive it
+   * as an intervention; idle members see it on their next task.
+   */
+  async broadcast(message) {
+    const body = message.trim();
+    if (!body) throw new Error("Message must not be empty");
+    const record = await this.mailbox.send({
+      teamId: this.teamId,
+      from: "coordinator",
+      kind: "broadcast",
+      body,
+      payload: { kind: "guidance" },
+      metadata: { payloadKind: "guidance" }
+    });
+    await this.emit({
+      type: "team-message",
+      teamId: this.teamId,
+      message: record
+    });
+    const recipients = [];
+    for (const runtime of this.members.values()) {
+      if (runtime.member.status === "busy") {
+        runtime.lastDeliveredMessageAt = record.createdAt;
+        runtime.lastDeliveredMessageId = record.id;
+        if (runtime.taskAbort || this.taskDispatchMode !== "external") {
+          runtime.agent.intervene(body);
+        } else if (this.externalTaskControl?.guideTask && runtime.member.activeTaskId) {
+          const activeTask = await this.taskBoard.getTask(runtime.member.activeTaskId);
+          if (activeTask) {
+            void this.externalTaskControl.guideTask({
+              task: activeTask,
+              runtime,
+              message: body
+            }).catch((err) => {
+              this.log(`External guideTask (broadcast) failed for @${runtime.member.id}: ${err instanceof Error ? err.message : String(err)}`);
+            });
+          }
+        }
+        recipients.push(runtime.member.id);
+      }
+    }
+    this.log(`Broadcast: "${body.length > 80 ? body.slice(0, 80) + "\u2026" : body}" \u2192 ${recipients.length > 0 ? recipients.join(", ") : "no active members"}`);
+    return record;
+  }
+  // ── Shutdown protocol ──────────────────────────────────────────────
+  /**
+   * Request graceful shutdown of a specific member.
+   *
+   * - If member is idle, auto-accepts and goes offline immediately
+   * - If member is busy, marks as shutting-down and waits for current
+   *   task to finish before going offline
+   * - Returns true if shutdown succeeded within the timeout
+   */
+  async requestShutdown(memberId, reason, timeoutMs) {
+    return requestShutdown(this, memberId, reason, timeoutMs);
+  }
+  /**
+   * Gracefully shut down all members.
+   */
+  async shutdown(reason, timeoutMs) {
+    return shutdownAll(this, reason, timeoutMs);
+  }
+  // ── Permission forwarding ──────────────────────────────────────────
+  /**
+   * Handle a permission request forwarded from a team member.
+   * Called by the `teamPermissionPolicy` middleware when it has
+   * a `forwardApproval` callback pointing at the coordinator.
+   */
+  async handlePermissionRequest(memberId, tool, args) {
+    const requestId = this.createId();
+    await this.emit({
+      type: "team-permission-forwarded",
+      teamId: this.teamId,
+      memberId,
+      requestId,
+      tool
+    });
+    let result;
+    if (this.onPermissionRequest) {
+      result = await this.onPermissionRequest(memberId, tool, args);
+    } else {
+      result = { decision: "allow" };
+    }
+    await this.emit({
+      type: "team-permission-resolved",
+      teamId: this.teamId,
+      memberId,
+      requestId,
+      decision: result.decision
+    });
+    return result;
+  }
+  /**
+   * Create a `forwardApproval` callback for `teamPermissionPolicy`
+   * that routes through this coordinator's permission handler.
+   */
+  createPermissionForwarder(memberId) {
+    return async (_memberId, tool, args, _ctx) => {
+      const result = await this.handlePermissionRequest(memberId, tool, args);
+      return { action: result.decision, reason: result.reason };
+    };
+  }
+  /** @internal */
+  beginCoordinatorTurnState() {
+    this.coordinatorTurnState = {
+      actions: {
+        assigned: [],
+        sentMessages: [],
+        abortedTaskIds: []
+      }
+    };
+    return this.coordinatorTurnState;
+  }
+  /** @internal */
+  getActiveCoordinatorTurnState() {
+    if (!this.coordinatorTurnState) {
+      throw new Error("No active coordinator turn state");
+    }
+    return this.coordinatorTurnState;
+  }
+  /** @internal */
+  endCoordinatorTurnState() {
+    this.coordinatorTurnState = null;
+  }
+  /** @internal */
+  getCoordinatorInboxSize() {
+    return this.coordinatorInbox.length;
+  }
+  /** @internal */
+  async getActiveTaskCount() {
+    const tasks = await this.taskBoard.listTasks();
+    return tasks.filter(
+      (task) => task.status !== "completed" && task.status !== "aborted" && task.status !== "failed" && task.status !== "cancelled"
+    ).length;
+  }
+  /** @internal */
+  ensureCoordinatorAgent() {
+    if (!this.coordinatorAgent) {
+      this.coordinatorAgent = createCoordinatorAgent(this);
+      this.coordinatorSessionId = `team:${this.teamId}:coordinator`;
+      this.attachCoordinatorTurn(this.coordinatorAgent, this.coordinatorSessionId);
+    }
+    return this.coordinatorAgent;
+  }
+  /** @internal */
+  getCoordinatorSessionId() {
+    return this.coordinatorSessionId;
+  }
+  resetCoordinatorRunSession() {
+    const agent = this.ensureCoordinatorAgent();
+    this.detachCoordinatorTurn();
+    this.coordinatorInbox = [];
+    this.coordinatorReschedule = false;
+    this.coordinatorProcessing = false;
+    this.endCoordinatorTurnState();
+    this.coordinatorRoundNumber = 0;
+    this.coordinatorRunSequence += 1;
+    this.coordinatorSessionId = `team:${this.teamId}:coordinator:run-${this.coordinatorRunSequence}`;
+    this.attachCoordinatorTurn(agent, this.coordinatorSessionId);
+    this.publishCoordinatorStatus({
+      phase: "ready",
+      message: "Ready",
+      pendingInboxCount: 0,
+      activeTaskCount: 0
+    });
+  }
+  enqueueCoordinatorInboxItem(item) {
+    enqueueInboxItem(this, item);
+  }
+  enqueueCoordinatorNotification(notification) {
+    enqueueNotification(this, notification);
+  }
+  /** @internal */
+  scheduleCoordinatorProcessing() {
+    scheduleProcessing(this);
+  }
+  /** @internal */
+  autonomousTurnCount = 0;
+  async waitForCoordinatorIdle() {
+    if (!this.coordinatorProcessing && this.coordinatorInbox.length === 0 && (this.coordinatorStatus.phase === "ready" || this.coordinatorStatus.phase === "error")) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.coordinatorIdleResolvers.push(resolve);
+    });
+  }
+  submitToCoordinator(message) {
+    const body = message.trim();
+    if (!body) {
+      throw new Error("Coordinator message must not be empty");
+    }
+    const id = this.createId();
+    this.log(`submitToCoordinator: id=${id} body="${body.length > 80 ? body.slice(0, 80) + "\u2026" : body}" (processing=${this.coordinatorProcessing}, inbox=${this.coordinatorInbox.length})`);
+    this.enqueueCoordinatorInboxItem({
+      id,
+      kind: "user-message",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      body
+    });
+    this.scheduleCoordinatorProcessing();
+    return id;
+  }
+  subscribeCoordinatorEvents(listener) {
+    this.coordinatorEventListeners.add(listener);
+    return () => {
+      this.coordinatorEventListeners.delete(listener);
+    };
+  }
+  subscribeCoordinatorStatus(listener) {
+    this.coordinatorStatusListeners.add(listener);
+    listener({ ...this.coordinatorStatus });
+    return () => {
+      this.coordinatorStatusListeners.delete(listener);
+    };
+  }
+  getCoordinatorStatus() {
+    return { ...this.coordinatorStatus };
+  }
+  /** @internal */
+  attachCoordinatorTurn(agent, sessionId) {
+    this.activeCoordinatorTurn = { agent, sessionId, turnOpen: false };
+  }
+  /** @internal */
+  setCoordinatorTurnOpen(open) {
+    if (!this.activeCoordinatorTurn) {
+      return;
+    }
+    this.activeCoordinatorTurn.turnOpen = open;
+  }
+  /** @internal */
+  detachCoordinatorTurn(agent) {
+    if (!this.activeCoordinatorTurn) {
+      return;
+    }
+    if (agent && this.activeCoordinatorTurn.agent !== agent) {
+      return;
+    }
+    this.activeCoordinatorTurn = void 0;
+  }
+  // ── Coordinator loop ──────────────────────────────────────────────
+  /**
+   * Run the coordinator in an iterative loop.
+   *
+   * The lead agent is forked with delegation tools and a coordinator
+   * system prompt. It reasons about the request, assigns tasks to
+   * teammates, receives results, and continues until all work is done.
+   *
+   * This replaces the plan → fan-out → synthesize pipeline with a
+   * dynamic multi-round conversation where the coordinator decides
+   * what to delegate, how to react to results, and when it's done.
+   *
+   * Members must be registered before calling this method.
+   *
+   * @param prompt  - The user's request
+   * @param options - Loop configuration (max rounds, timeouts, progress callback)
+   */
+  async run(prompt, options) {
+    this.resetCoordinatorRunSession();
+    const rounds = [];
+    let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    let lastResponse = "";
+    const unsubEvents = this.subscribeCoordinatorEvents((event) => {
+      options?.onCoordinatorEvent?.(event);
+      if (event.type === "step-finish" && event.usage) {
+        totalUsage = {
+          inputTokens: (totalUsage.inputTokens ?? 0) + (event.usage.inputTokens ?? 0),
+          outputTokens: (totalUsage.outputTokens ?? 0) + (event.usage.outputTokens ?? 0),
+          totalTokens: (totalUsage.totalTokens ?? 0) + (event.usage.totalTokens ?? 0)
+        };
+      }
+      if (event.type === "complete" && typeof event.output === "string") {
+        lastResponse = event.output;
+      }
+    });
+    const unsubStatus = this.subscribeCoordinatorStatus((status) => {
+      const mappedPhase = status.phase === "running" ? "thinking" : status.phase === "waiting" ? "waiting" : "done";
+      options?.onStatus?.({
+        phase: mappedPhase,
+        round: this.coordinatorRoundNumber,
+        message: status.message
+      });
+    });
+    const unsubTeam = this.subscribeTeamEvents((event) => {
+      if (event.type !== "team-coordinator-round") {
+        return;
+      }
+      const round = {
+        number: event.roundNumber,
+        assigned: [...event.assigned],
+        messaged: [...event.messaged],
+        stopped: [...event.stopped],
+        completions: [...event.completions],
+        reports: [...event.reports],
+        response: event.response,
+        usage: event.usage
+      };
+      rounds.push(round);
+      void options?.onRound?.(round);
+    });
+    try {
+      this.submitToCoordinator(prompt);
+      await this.waitForCoordinatorIdle();
+      return { response: lastResponse, rounds, usage: totalUsage };
+    } finally {
+      unsubEvents();
+      unsubStatus();
+      unsubTeam();
+    }
+  }
+  // ── Planning ────────────────────────────────────────────────────────
+  async plan(prompt, memberIds) {
+    return planTasks(this, prompt, memberIds);
+  }
+  async planAndExecute(prompt, memberIds) {
+    return planAndExecuteTasks(this, prompt, memberIds);
+  }
+  // ── Synthesis ──────────────────────────────────────────────────────
+  /**
+   * Use the lead agent to synthesize all completed task results
+   * into a single coherent response.
+   *
+   * @param originalPrompt - The original task/prompt
+   * @param taskIds - Optional subset of task IDs to synthesize (defaults to all terminal tasks)
+   */
+  async synthesize(originalPrompt, taskIds) {
+    return synthesizeResults(this, originalPrompt, taskIds);
+  }
+  // ── Queries ────────────────────────────────────────────────────────
+  async snapshot() {
+    const [board, messages] = await Promise.all([
+      this.taskBoard.snapshot(),
+      this.mailbox.list({ teamId: this.teamId })
+    ]);
+    return { ...board, messages };
+  }
+  async listMembers() {
+    return this.taskBoard.listMembers();
+  }
+  async listTasks(filter) {
+    return this.taskBoard.listTasks(filter);
+  }
+  async listMessages(filter) {
+    return this.mailbox.list({ ...filter, teamId: this.teamId });
+  }
+  getMemberSessionId(memberId) {
+    return this.requireMember(memberId).member.sessionId;
+  }
+  getMemberRole(memberId) {
+    return this.requireMember(memberId).role.name;
+  }
+  async prepareTaskForExternalExecution(taskId, runId) {
+    const task = await this.taskBoard.getTask(taskId);
+    if (!task?.memberId) {
+      return void 0;
+    }
+    const runtime = this.members.get(task.memberId);
+    if (!runtime) {
+      return void 0;
+    }
+    return prepareTaskForExternalExecution(this, runtime, taskId, runId);
+  }
+  async completeExternalTask(taskId, result) {
+    const task = await this.taskBoard.getTask(taskId);
+    if (!task?.memberId) {
+      return void 0;
+    }
+    const runtime = this.members.get(task.memberId);
+    if (!runtime) {
+      return void 0;
+    }
+    try {
+      return await completePreparedTask(this, runtime, taskId, result);
+    } finally {
+      await this.finalizeExternallyTerminatedTask(runtime);
+    }
+  }
+  async failExternalTask(taskId, error) {
+    const task = await this.taskBoard.getTask(taskId);
+    if (!task?.memberId) {
+      return void 0;
+    }
+    const runtime = this.members.get(task.memberId);
+    if (!runtime) {
+      return void 0;
+    }
+    try {
+      return await failPreparedTask(this, runtime, taskId, error);
+    } finally {
+      await this.finalizeExternallyTerminatedTask(runtime);
+    }
+  }
+  async abortExternalTask(taskId, reason) {
+    const task = await this.taskBoard.getTask(taskId);
+    if (!task?.memberId) {
+      return void 0;
+    }
+    const runtime = this.members.get(task.memberId);
+    if (!runtime) {
+      return void 0;
+    }
+    try {
+      return await abortPreparedTask(this, runtime, taskId, reason);
+    } finally {
+      await this.finalizeExternallyTerminatedTask(runtime);
+    }
+  }
+  async getTask(taskId) {
+    return this.taskBoard.getTask(taskId);
+  }
+  /**
+   * Get aggregate stats for a member.
+   * Returns undefined if the member is not registered.
+   */
+  getMemberStats(memberId) {
+    return this.members.get(memberId)?.stats;
+  }
+  /**
+   * Subscribe to a member's agent events (text-delta, tool-start, etc.).
+   * Returns an unsubscribe function. Throws if the member is not registered.
+   */
+  onMemberEvent(memberId, handler) {
+    const runtime = this.members.get(memberId);
+    if (!runtime) {
+      throw new Error(`Member "${memberId}" is not registered`);
+    }
+    return runtime.agent.signal.onAny(handler);
+  }
+  /**
+   * Serialize the coordinator state for persistence / resume.
+   * Returns snapshot + member stats, enough to reconstruct state.
+   */
+  async toJSON() {
+    const snap = await this.snapshot();
+    const memberStats = {};
+    for (const [id, runtime] of this.members) {
+      memberStats[id] = { ...runtime.stats };
+    }
+    return { teamId: this.teamId, snapshot: snap, memberStats };
+  }
+  // ── Internal: member state (CoordinatorCtx) ────────────────────────
+  /** @internal */
+  async updateMemberStatus(memberId, status, activeTaskId) {
+    const runtime = this.members.get(memberId);
+    if (!runtime) return;
+    const previous = runtime.member.status;
+    const updated = {
+      ...runtime.member,
+      status,
+      activeTaskId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.taskBoard.putMember(updated);
+    runtime.member = updated;
+    if (previous !== status) {
+      await this.emit({
+        type: "team-member-status",
+        teamId: this.teamId,
+        memberId,
+        previous,
+        current: status,
+        activeTaskId
+      });
+    }
+  }
+  requireMember(memberId) {
+    const runtime = this.members.get(memberId);
+    if (!runtime) {
+      throw new Error(
+        `Unknown member: "${memberId}". Registered: ${[...this.members.keys()].join(", ")}`
+      );
+    }
+    return runtime;
+  }
+  // ── Internal: events (CoordinatorCtx) ──────────────────────────────
+  /** @internal */
+  async emit(event) {
+    await this.dispatchEvent(event);
+    if (event.type === "team-notification") {
+      this.log(`emit: team-notification kind=${event.notification.kind} member=${event.notification.memberId}`);
+      this.enqueueCoordinatorNotification(event.notification);
+      this.scheduleCoordinatorProcessing();
+      return;
+    }
+    try {
+      const notificationEvent = await buildCoordinatorNotificationEvent(
+        event,
+        (taskId) => this.taskBoard.getTask(taskId)
+      );
+      if (notificationEvent) {
+        this.log(`emit: ${event.type} \u2192 notification kind=${notificationEvent.notification.kind} member=${notificationEvent.notification.memberId}`);
+        await this.dispatchEvent(notificationEvent);
+        this.enqueueCoordinatorNotification(notificationEvent.notification);
+        this.scheduleCoordinatorProcessing();
+      }
+    } catch {
+    }
+  }
+  /** @internal */
+  async emitTransitions(transitions) {
+    for (const t of transitions) {
+      if (t.reason === "created") {
+        await this.emit({
+          type: "team-task-created",
+          teamId: this.teamId,
+          task: t.task
+        });
+      }
+      if (t.previous !== void 0) {
+        this.log(`Task "${t.task.title}" (${t.task.memberId ?? "?"}): ${t.previous} \u2192 ${t.task.status}${t.reason ? ` (${t.reason})` : ""}`);
+        await this.emit({
+          type: "team-task-transition",
+          teamId: this.teamId,
+          taskId: t.task.id,
+          previous: t.previous,
+          current: t.task.status,
+          reason: t.reason
+        });
+      }
+    }
+  }
+  async finalizeExternallyTerminatedTask(runtime) {
+    if (runtime.stopRequested || runtime.member.status === "shutting-down") {
+      await this.updateMemberStatus(runtime.member.id, "offline", void 0);
+      return;
+    }
+    await this.updateMemberStatus(runtime.member.id, "idle", void 0);
+    if (this.taskDispatchMode === "manual") {
+      await this.dispatchReady();
+    }
+  }
+};
+function createTeamCoordinator(config) {
+  return new TeamCoordinator(config);
+}
+
+// src/team/coordinator/round-engine.ts
+function addTokenUsage(total, usage) {
+  return {
+    inputTokens: (total.inputTokens ?? 0) + (usage?.inputTokens ?? 0),
+    outputTokens: (total.outputTokens ?? 0) + (usage?.outputTokens ?? 0),
+    totalTokens: (total.totalTokens ?? 0) + (usage?.totalTokens ?? 0)
+  };
+}
+function evaluateCoordinatorRoundTransition(input) {
+  if (input.reasonAssignmentsCount === 0 && input.activeTaskCount === 0 && input.terminalAfterEvent && input.reports.length === 0) {
+    return {
+      kind: "done",
+      finalResponse: input.reasonResponse
+    };
+  }
+  if (input.notifications.length === 0 && input.reports.length === 0 && input.activeTaskCount === 0) {
+    if (!input.terminalAfterEvent) {
+      return {
+        kind: "continue",
+        nextMessage: input.blockedMessage
+      };
+    }
+    return {
+      kind: "done",
+      finalResponse: input.reasonAssignmentsCount === 0 && input.terminalAfterEvent ? input.reasonResponse : input.roundResponse
+    };
+  }
+  if (input.notifications.length === 0 && input.reports.length === 0 && input.activeTaskCount > 0) {
+    return {
+      kind: "wait",
+      nextMessage: ""
+    };
+  }
+  return {
+    kind: "continue",
+    nextMessage: formatCoordinatorRoundMessage(
+      input.notifications,
+      input.reports
+    )
+  };
+}
+
+export {
+  TERMINAL_STATUSES,
+  TaskConflictError,
+  InMemoryTaskBoardStore,
+  TaskBoard,
+  InMemoryMailboxStore,
+  Mailbox,
+  teamPermissionPolicy,
+  coordinatorToolDescriptions,
+  buildCoordinatorSystemPrompt,
+  formatCoordinatorTaskNotifications,
+  formatCoordinatorWorkerReports,
+  formatCoordinatorRoundMessage,
+  buildCoordinatorNotificationEvent,
+  TeamCoordinator,
+  createTeamCoordinator,
+  addTokenUsage,
+  evaluateCoordinatorRoundTransition
+};