aemeathcli 1.0.0

package/dist/chunk-HMJRPNPZ.js

@@ -0,0 +1,1031 @@
+import { getEventBus } from './chunk-YL5XFHR3.js';
+import { getIPCSocketPath, getTasksDir, ensureDirectory, getTeamsDir } from './chunk-NBR3GHMT.js';
+import { AgentSpawnError } from './chunk-ZGOHARPV.js';
+import { logger } from './chunk-JAXXTYID.js';
+import { join } from 'path';
+import { writeFileSync, renameSync, unlinkSync, existsSync, readFileSync, readdirSync, rmSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { fork } from 'child_process';
+
+var DEFAULT_SHUTDOWN_TIMEOUT_MS = 1e4;
+var DEFAULT_REGISTRATION_TIMEOUT_MS = 15e3;
+var AgentProcess = class {
+  config;
+  teamName;
+  sessionId;
+  cliEntryPoint;
+  customEnv;
+  shutdownTimeoutMs;
+  registrationTimeoutMs;
+  messageCallbacks = /* @__PURE__ */ new Set();
+  child = null;
+  status = "idle";
+  currentTaskId;
+  nextMessageId = 1;
+  constructor(config, options) {
+    this.config = config;
+    this.teamName = options.teamName;
+    this.sessionId = options.sessionId;
+    this.cliEntryPoint = options.cliEntryPoint ?? process.argv[1] ?? "aemeathcli";
+    this.customEnv = options.env ?? {};
+    this.shutdownTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+    this.registrationTimeoutMs = options.registrationTimeoutMs ?? DEFAULT_REGISTRATION_TIMEOUT_MS;
+  }
+  /** Spawn the child process. Throws AgentSpawnError on failure. */
+  async start() {
+    if (this.child) {
+      throw new AgentSpawnError(
+        this.config.name,
+        "Agent process already running"
+      );
+    }
+    const args = [
+      "--agent",
+      "--team",
+      this.teamName,
+      "--name",
+      this.config.name,
+      "--model",
+      this.config.model,
+      "--role",
+      this.config.role
+    ];
+    const socketPath = getIPCSocketPath(this.sessionId);
+    const env = {
+      ...process.env,
+      ...this.customEnv,
+      AEMEATHCLI_AGENT_MODE: "1",
+      AEMEATHCLI_TEAM_NAME: this.teamName,
+      AEMEATHCLI_AGENT_ID: this.config.agentId,
+      AEMEATHCLI_AGENT_NAME: this.config.name,
+      AEMEATHCLI_IPC_SOCKET: socketPath,
+      // Prefer SDK adapters when API keys are available (not OAuth/native login).
+      // Native login credentials always use native CLI adapters regardless of
+      // this flag — the registry enforces this to avoid "invalid API key" errors.
+      AEMEATHCLI_PREFER_SDK: "1",
+      // Increase timeout for native CLI fallback (agent tasks can be long).
+      AEMEATHCLI_NATIVE_CLI_TIMEOUT_MS: "300000"
+    };
+    try {
+      this.child = fork(this.cliEntryPoint, args, {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        env,
+        detached: false
+      });
+      this.setupChildListeners();
+      this.setStatus("idle");
+      await this.waitForRegistration();
+      getEventBus().emit("agent:spawned", {
+        agentName: this.config.name,
+        model: this.config.model
+      });
+      logger.info(
+        {
+          agent: this.config.name,
+          pid: this.child.pid,
+          model: this.config.model
+        },
+        "Agent process spawned"
+      );
+    } catch (error) {
+      if (this.child) {
+        this.child.kill("SIGTERM");
+        this.child = null;
+      }
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new AgentSpawnError(this.config.name, reason);
+    }
+  }
+  /** Gracefully stop the agent. Falls back to SIGTERM after timeout. */
+  async stop() {
+    if (!this.child) return;
+    const child = this.child;
+    this.sendIPC("hub.shutdown", { reason: "team_cleanup" });
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (child.exitCode === null) {
+          logger.warn(
+            { agent: this.config.name },
+            "Force-killing unresponsive agent"
+          );
+          child.kill("SIGTERM");
+        }
+        resolve();
+      }, this.shutdownTimeoutMs);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+    this.cleanup();
+    logger.info({ agent: this.config.name }, "Agent process stopped");
+  }
+  /** Kill and restart the agent process. */
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+  /** Send a JSON-RPC 2.0 message to the child process. Returns message ID. */
+  sendIPC(method, params) {
+    if (!this.child?.connected) {
+      logger.warn(
+        { agent: this.config.name, method },
+        "Cannot send IPC: child not connected"
+      );
+      return -1;
+    }
+    const id = this.nextMessageId++;
+    const message = {
+      jsonrpc: "2.0",
+      method,
+      params,
+      id
+    };
+    this.child.send(message);
+    return id;
+  }
+  /** Assign a task to this agent via IPC. */
+  assignTask(taskId, subject, description) {
+    this.currentTaskId = taskId;
+    return this.sendIPC("hub.taskAssign", { taskId, subject, description });
+  }
+  /** Register a callback for IPC messages from the child process. */
+  onMessage(callback) {
+    this.messageCallbacks.add(callback);
+    return () => {
+      this.messageCallbacks.delete(callback);
+    };
+  }
+  /** Get the current agent state snapshot. */
+  getState() {
+    return {
+      config: this.config,
+      status: this.status,
+      currentTaskId: this.currentTaskId
+    };
+  }
+  /** Get the current status. */
+  getStatus() {
+    return this.status;
+  }
+  /** Get the child process PID, or undefined if not running. */
+  getPid() {
+    return this.child?.pid;
+  }
+  /** Check if the child process is alive. */
+  isAlive() {
+    return this.child !== null && this.child.exitCode === null;
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  setupChildListeners() {
+    const child = this.child;
+    if (!child) return;
+    child.stdout?.on("data", (chunk) => {
+      const content = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      if (content.length > 0) {
+        logger.debug(
+          { agent: this.config.name, bytes: content.length },
+          "Agent stdout (suppressed from UI)"
+        );
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      const content = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      if (content.length > 0) {
+        logger.warn(
+          { agent: this.config.name, stderr: content.slice(0, 200) },
+          "Agent stderr"
+        );
+      }
+    });
+    child.on("message", (raw) => {
+      this.handleChildMessage(raw);
+    });
+    child.on("error", (error) => {
+      logger.error(
+        { agent: this.config.name, error: error.message },
+        "Agent process error"
+      );
+      this.setStatus("error");
+    });
+    child.on("exit", (code, signal) => {
+      logger.info(
+        { agent: this.config.name, code, signal },
+        "Agent process exited"
+      );
+      this.setStatus("shutdown");
+      this.child = null;
+    });
+    child.on("disconnect", () => {
+      logger.debug({ agent: this.config.name }, "Agent IPC disconnected");
+    });
+  }
+  handleChildMessage(raw) {
+    if (!isIPCMessage(raw)) {
+      logger.warn(
+        { agent: this.config.name },
+        "Received non-IPC message from child"
+      );
+      return;
+    }
+    const { method, params } = raw;
+    switch (method) {
+      case "agent.register":
+        logger.debug({ agent: this.config.name }, "Agent registered via IPC");
+        break;
+      case "agent.taskUpdate": {
+        const taskStatus = params["status"];
+        if (typeof taskStatus === "string") {
+          if (taskStatus === "in_progress") {
+            this.setStatus("active");
+          } else if (taskStatus === "completed") {
+            this.currentTaskId = void 0;
+            this.setStatus("idle");
+          }
+        }
+        break;
+      }
+    }
+    this.notifyCallbacks(method, params);
+  }
+  /** Wait for the child to send agent.register. Rejects on timeout or early exit. */
+  async waitForRegistration() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.child?.removeListener("message", onMessage);
+        reject(new Error("Agent registration timeout"));
+      }, this.registrationTimeoutMs);
+      const onMessage = (raw) => {
+        if (isIPCMessage(raw) && raw.method === "agent.register") {
+          clearTimeout(timeout);
+          this.child?.removeListener("message", onMessage);
+          this.child?.removeListener("exit", onExit);
+          resolve();
+        }
+      };
+      const onExit = () => {
+        clearTimeout(timeout);
+        this.child?.removeListener("message", onMessage);
+        reject(new Error("Agent process exited before registration"));
+      };
+      this.child?.on("message", onMessage);
+      this.child?.once("exit", onExit);
+    });
+  }
+  setStatus(status) {
+    this.status = status;
+    getEventBus().emit("agent:status", {
+      agentName: this.config.name,
+      status
+    });
+  }
+  notifyCallbacks(method, params) {
+    for (const callback of this.messageCallbacks) {
+      try {
+        callback(method, params);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.error(
+          { agent: this.config.name, error: reason },
+          "Message callback threw"
+        );
+      }
+    }
+  }
+  cleanup() {
+    this.child = null;
+    this.currentTaskId = void 0;
+    this.messageCallbacks.clear();
+  }
+};
+function isIPCMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return obj["jsonrpc"] === "2.0" && typeof obj["method"] === "string" && typeof obj["params"] === "object" && obj["params"] !== null;
+}
+var MessageBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  queues = /* @__PURE__ */ new Map();
+  statuses = /* @__PURE__ */ new Map();
+  transport;
+  transportUnsubscribe;
+  destroyed = false;
+  constructor(options) {
+    this.transport = options?.transport;
+    if (this.transport) {
+      this.transportUnsubscribe = this.transport.onReceive((message) => {
+        this.routeIncoming(message);
+      });
+    }
+  }
+  /** Register an agent as available for message delivery. */
+  registerAgent(agentId) {
+    if (!this.handlers.has(agentId)) {
+      this.handlers.set(agentId, /* @__PURE__ */ new Set());
+    }
+    if (!this.queues.has(agentId)) {
+      this.queues.set(agentId, []);
+    }
+    this.statuses.set(agentId, "idle");
+    logger.debug({ agentId }, "Agent registered on message bus");
+  }
+  /** Remove an agent from the bus. Pending messages are discarded. */
+  unregisterAgent(agentId) {
+    this.handlers.delete(agentId);
+    this.queues.delete(agentId);
+    this.statuses.delete(agentId);
+    logger.debug({ agentId }, "Agent unregistered from message bus");
+  }
+  /** Subscribe to messages delivered to an agent. Returns unsubscribe function. */
+  subscribe(agentId, handler) {
+    let handlerSet = this.handlers.get(agentId);
+    if (!handlerSet) {
+      handlerSet = /* @__PURE__ */ new Set();
+      this.handlers.set(agentId, handlerSet);
+    }
+    handlerSet.add(handler);
+    return () => {
+      handlerSet.delete(handler);
+    };
+  }
+  /** Route a message to its recipient(s). Returns true if delivered or queued. */
+  send(message) {
+    if (this.destroyed) {
+      logger.warn("MessageBus is destroyed, dropping message");
+      return false;
+    }
+    if (message.type === "broadcast") {
+      return this.broadcastToAll(message);
+    }
+    if (!message.recipientId) {
+      logger.warn(
+        { type: message.type, senderId: message.senderId },
+        "Non-broadcast message missing recipientId"
+      );
+      return false;
+    }
+    return this.deliverToAgent(message.recipientId, message);
+  }
+  /** Create a well-formed message and send it. Returns the created message. */
+  createAndSend(type, senderId, recipientId, content, extra) {
+    const message = {
+      type,
+      senderId,
+      recipientId,
+      content,
+      summary: extra?.summary,
+      requestId: extra?.requestId ?? randomUUID(),
+      approve: extra?.approve,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.send(message);
+    return message;
+  }
+  /** Update an agent's status. Drains the queue when transitioning to idle. */
+  setAgentStatus(agentId, status) {
+    const previous = this.statuses.get(agentId);
+    this.statuses.set(agentId, status);
+    if (status === "idle" && previous === "active") {
+      this.drainQueue(agentId);
+    }
+  }
+  /** Get the number of queued messages for an agent. */
+  getQueueSize(agentId) {
+    return this.queues.get(agentId)?.length ?? 0;
+  }
+  /** Get all registered agent IDs. */
+  getRegisteredAgents() {
+    return [...this.handlers.keys()];
+  }
+  /** Tear down the message bus and release resources. */
+  destroy() {
+    this.destroyed = true;
+    this.transportUnsubscribe?.();
+    this.handlers.clear();
+    this.queues.clear();
+    this.statuses.clear();
+    logger.debug("MessageBus destroyed");
+  }
+  // ── Private Routing ─────────────────────────────────────────────────
+  broadcastToAll(message) {
+    let delivered = false;
+    for (const agentId of this.handlers.keys()) {
+      if (agentId === message.senderId) continue;
+      const copy = { ...message, recipientId: agentId };
+      this.deliverToAgent(agentId, copy);
+      delivered = true;
+    }
+    return delivered;
+  }
+  deliverToAgent(agentId, message) {
+    const status = this.statuses.get(agentId);
+    if (status === "active") {
+      this.enqueue(agentId, message);
+      logger.debug(
+        { agentId, type: message.type },
+        "Agent busy, message queued"
+      );
+      return true;
+    }
+    const handlerSet = this.handlers.get(agentId);
+    if (handlerSet && handlerSet.size > 0) {
+      this.invokeHandlers(agentId, handlerSet, message);
+      return true;
+    }
+    if (this.transport) {
+      this.transport.send(agentId, message).catch((error) => {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.error({ agentId, error: reason }, "Transport delivery failed");
+      });
+      return true;
+    }
+    this.enqueue(agentId, message);
+    return true;
+  }
+  invokeHandlers(agentId, handlerSet, message) {
+    for (const handler of handlerSet) {
+      try {
+        handler(message);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.error({ agentId, error: reason }, "Message handler threw");
+      }
+    }
+    getEventBus().emit("agent:message", {
+      from: message.senderId,
+      to: agentId,
+      content: message.content
+    });
+  }
+  enqueue(agentId, message) {
+    let queue = this.queues.get(agentId);
+    if (!queue) {
+      queue = [];
+      this.queues.set(agentId, queue);
+    }
+    queue.push(message);
+  }
+  drainQueue(agentId) {
+    const queue = this.queues.get(agentId);
+    if (!queue || queue.length === 0) return;
+    const handlerSet = this.handlers.get(agentId);
+    if (!handlerSet || handlerSet.size === 0) return;
+    const pending = queue.splice(0);
+    logger.debug({ agentId, count: pending.length }, "Draining message queue");
+    for (const message of pending) {
+      this.invokeHandlers(agentId, handlerSet, message);
+    }
+  }
+  routeIncoming(message) {
+    if (message.type === "broadcast") {
+      this.broadcastToAll(message);
+    } else if (message.recipientId) {
+      this.deliverToAgent(message.recipientId, message);
+    }
+  }
+};
+var TaskStore = class _TaskStore {
+  storeDir;
+  constructor(teamName) {
+    this.storeDir = join(getTasksDir(), teamName);
+    ensureDirectory(this.storeDir);
+    this.cleanupTempFiles();
+  }
+  /** Persist a task to disk with atomic write (temp + rename). */
+  save(task) {
+    const serialized = _TaskStore.serialize(task);
+    const filePath = this.getTaskFilePath(task.id);
+    const tmpPath = `${filePath}.tmp`;
+    try {
+      writeFileSync(tmpPath, JSON.stringify(serialized, null, 2), {
+        encoding: "utf-8",
+        mode: 420
+      });
+      renameSync(tmpPath, filePath);
+      logger.debug({ taskId: task.id }, "Task persisted to disk");
+    } catch (error) {
+      try {
+        unlinkSync(tmpPath);
+      } catch {
+      }
+      const reason = error instanceof Error ? error.message : String(error);
+      logger.error({ taskId: task.id, error: reason }, "Failed to save task");
+      throw error;
+    }
+  }
+  /** Load a single task by ID. Throws if not found. */
+  load(taskId) {
+    const filePath = this.getTaskFilePath(taskId);
+    if (!existsSync(filePath)) {
+      throw new Error(`Task file not found: ${taskId}`);
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    return _TaskStore.deserialize(data);
+  }
+  /** Load all tasks for this team, sorted by creation time. */
+  loadAll() {
+    if (!existsSync(this.storeDir)) {
+      return [];
+    }
+    const files = readdirSync(this.storeDir).filter(
+      (f) => f.endsWith(".json") && !f.endsWith(".tmp")
+    );
+    const tasks = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(this.storeDir, file), "utf-8");
+        const data = JSON.parse(raw);
+        tasks.push(_TaskStore.deserialize(data));
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.warn({ file, error: reason }, "Skipping corrupt task file");
+      }
+    }
+    return tasks.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  }
+  /** Remove a task file from disk. Returns true if deleted. */
+  remove(taskId) {
+    const filePath = this.getTaskFilePath(taskId);
+    if (!existsSync(filePath)) {
+      return false;
+    }
+    try {
+      unlinkSync(filePath);
+      logger.debug({ taskId }, "Task file removed");
+      return true;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      logger.error({ taskId, error: reason }, "Failed to remove task file");
+      return false;
+    }
+  }
+  /** Check whether a task file exists on disk. */
+  exists(taskId) {
+    return existsSync(this.getTaskFilePath(taskId));
+  }
+  /** Absolute path to this team's task store directory. */
+  getStorePath() {
+    return this.storeDir;
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  getTaskFilePath(taskId) {
+    return join(this.storeDir, `${taskId}.json`);
+  }
+  /** Remove orphaned .tmp files left from interrupted writes. */
+  cleanupTempFiles() {
+    if (!existsSync(this.storeDir)) return;
+    const tmpFiles = readdirSync(this.storeDir).filter(
+      (f) => f.endsWith(".tmp")
+    );
+    for (const file of tmpFiles) {
+      try {
+        unlinkSync(join(this.storeDir, file));
+      } catch {
+      }
+    }
+    if (tmpFiles.length > 0) {
+      logger.info(
+        { count: tmpFiles.length },
+        "Cleaned up stale temp task files"
+      );
+    }
+  }
+  static serialize(task) {
+    return {
+      id: task.id,
+      subject: task.subject,
+      description: task.description,
+      status: task.status,
+      owner: task.owner,
+      model: task.model,
+      role: task.role,
+      blocks: [...task.blocks],
+      blockedBy: [...task.blockedBy],
+      createdAt: task.createdAt.toISOString(),
+      updatedAt: task.updatedAt.toISOString()
+    };
+  }
+  static deserialize(data) {
+    return {
+      id: data.id,
+      subject: data.subject,
+      description: data.description,
+      status: data.status,
+      owner: data.owner,
+      model: data.model,
+      role: data.role,
+      blocks: [...data.blocks],
+      blockedBy: [...data.blockedBy],
+      createdAt: new Date(data.createdAt),
+      updatedAt: new Date(data.updatedAt)
+    };
+  }
+};
+var DEFAULT_TIMEOUT_MS = 3e5;
+var DEFAULT_LEADER_ID = "leader";
+var PlanApproval = class {
+  messageBus;
+  leaderId;
+  timeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  destroyed = false;
+  constructor(messageBus, options) {
+    this.messageBus = messageBus;
+    this.leaderId = options?.leaderId ?? DEFAULT_LEADER_ID;
+    this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  /**
+   * Submit a plan for approval. Returns a promise that resolves
+   * when the leader approves or rejects, or rejects on timeout.
+   */
+  submitPlan(agentId, plan) {
+    if (this.destroyed) {
+      return Promise.reject(new Error("PlanApproval has been destroyed"));
+    }
+    const requestId = randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`Plan approval timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+      const request = {
+        requestId,
+        agentId,
+        plan,
+        submittedAt: /* @__PURE__ */ new Date(),
+        resolve,
+        reject,
+        timer
+      };
+      this.pending.set(requestId, request);
+      this.messageBus.createAndSend(
+        "plan_approval_request",
+        agentId,
+        this.leaderId,
+        plan,
+        { requestId, summary: `Plan from ${agentId} awaiting review` }
+      );
+      logger.info({ requestId, agentId }, "Plan submitted for approval");
+    });
+  }
+  /** Leader approves a pending plan. Returns false if no matching request. */
+  approvePlan(requestId, responderId) {
+    const request = this.pending.get(requestId);
+    if (!request) {
+      logger.warn({ requestId }, "No pending plan for this requestId");
+      return false;
+    }
+    clearTimeout(request.timer);
+    this.pending.delete(requestId);
+    const result = {
+      approved: true,
+      requestId,
+      respondedBy: responderId,
+      respondedAt: /* @__PURE__ */ new Date()
+    };
+    this.messageBus.createAndSend(
+      "plan_approval_response",
+      responderId,
+      request.agentId,
+      "Plan approved",
+      { requestId, approve: true }
+    );
+    request.resolve(result);
+    logger.info({ requestId, agentId: request.agentId }, "Plan approved");
+    return true;
+  }
+  /** Leader rejects a pending plan with feedback. */
+  rejectPlan(requestId, responderId, feedback) {
+    const request = this.pending.get(requestId);
+    if (!request) {
+      logger.warn({ requestId }, "No pending plan for this requestId");
+      return false;
+    }
+    clearTimeout(request.timer);
+    this.pending.delete(requestId);
+    const result = {
+      approved: false,
+      feedback,
+      requestId,
+      respondedBy: responderId,
+      respondedAt: /* @__PURE__ */ new Date()
+    };
+    this.messageBus.createAndSend(
+      "plan_approval_response",
+      responderId,
+      request.agentId,
+      feedback,
+      { requestId, approve: false }
+    );
+    request.resolve(result);
+    logger.info(
+      { requestId, agentId: request.agentId, feedback },
+      "Plan rejected"
+    );
+    return true;
+  }
+  /**
+   * Handle an incoming plan_approval_response message.
+   * Call this from a message bus subscription to close the request loop.
+   */
+  handleResponse(message) {
+    if (message.type !== "plan_approval_response" || !message.requestId) {
+      return;
+    }
+    const request = this.pending.get(message.requestId);
+    if (!request) return;
+    clearTimeout(request.timer);
+    this.pending.delete(message.requestId);
+    const result = {
+      approved: message.approve === true,
+      feedback: message.approve === true ? void 0 : message.content,
+      requestId: message.requestId,
+      respondedBy: message.senderId,
+      respondedAt: /* @__PURE__ */ new Date()
+    };
+    request.resolve(result);
+  }
+  /** Cancel a pending plan request. */
+  cancelPlan(requestId) {
+    const request = this.pending.get(requestId);
+    if (!request) return false;
+    clearTimeout(request.timer);
+    this.pending.delete(requestId);
+    request.reject(new Error("Plan approval cancelled"));
+    logger.info({ requestId, agentId: request.agentId }, "Plan cancelled");
+    return true;
+  }
+  /** Get all pending plan requests (for leader UI). */
+  getPendingPlans() {
+    return [...this.pending.values()].map((req) => ({
+      requestId: req.requestId,
+      agentId: req.agentId,
+      plan: req.plan,
+      submittedAt: req.submittedAt
+    }));
+  }
+  /** Get the count of pending plans. */
+  getPendingCount() {
+    return this.pending.size;
+  }
+  /** Tear down: cancel all pending plans and release resources. */
+  destroy() {
+    this.destroyed = true;
+    for (const [, request] of this.pending) {
+      clearTimeout(request.timer);
+      request.reject(new Error("PlanApproval destroyed"));
+    }
+    this.pending.clear();
+    logger.debug("PlanApproval destroyed");
+  }
+};
+
+// src/teams/team-manager.ts
+var TEAM_NAME_PATTERN = /^[\w-]+$/;
+var TeamManager = class {
+  activeTeams = /* @__PURE__ */ new Map();
+  /** Create a new team: config, directories, and agent process handles. */
+  async createTeam(name, options) {
+    if (this.activeTeams.has(name)) {
+      throw new Error(`Team already exists: ${name}`);
+    }
+    if (!TEAM_NAME_PATTERN.test(name)) {
+      throw new Error(
+        `Invalid team name: "${name}". Use alphanumeric characters, dashes, or underscores.`
+      );
+    }
+    const teamDir = join(getTeamsDir(), name);
+    if (existsSync(teamDir)) {
+      throw new Error(`Team directory already exists: ${teamDir}`);
+    }
+    const members = options.agents.map((def) => ({
+      name: def.name,
+      agentId: randomUUID(),
+      agentType: def.agentType,
+      model: def.model,
+      provider: def.provider,
+      role: def.role
+    }));
+    const config = {
+      teamName: name,
+      description: options.description,
+      status: "active",
+      members,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    ensureDirectory(teamDir);
+    ensureDirectory(join(getTasksDir(), name));
+    this.saveTeamConfig(name, config);
+    const sessionId = options.sessionId ?? randomUUID();
+    const messageBus = new MessageBus();
+    const taskStore = new TaskStore(name);
+    const planApproval = new PlanApproval(messageBus);
+    const processes = /* @__PURE__ */ new Map();
+    for (const member of members) {
+      const processOptions = {
+        teamName: name,
+        sessionId,
+        cliEntryPoint: options.cliEntryPoint
+      };
+      const agentProcess = new AgentProcess(member, processOptions);
+      processes.set(member.name, agentProcess);
+      messageBus.registerAgent(member.agentId);
+    }
+    const activeTeam = {
+      config,
+      processes,
+      messageBus,
+      taskStore,
+      planApproval,
+      sessionId
+    };
+    this.activeTeams.set(name, activeTeam);
+    getEventBus().emit("team:created", {
+      teamName: name,
+      agentCount: members.length
+    });
+    logger.info(
+      { team: name, agents: members.length, sessionId },
+      "Team created"
+    );
+    return config;
+  }
+  /** Start all agent processes for a team. */
+  async startAgents(teamName) {
+    const team = this.getActiveTeam(teamName);
+    const startPromises = [];
+    for (const [agentName, agentProcess] of team.processes) {
+      startPromises.push(
+        agentProcess.start().catch((error) => {
+          const reason = error instanceof Error ? error.message : String(error);
+          logger.error(
+            { team: teamName, agent: agentName, error: reason },
+            "Failed to start agent"
+          );
+        })
+      );
+    }
+    await Promise.allSettled(startPromises);
+  }
+  /** Gracefully shutdown and remove a team. */
+  async deleteTeam(name) {
+    const active = this.activeTeams.get(name);
+    if (active) {
+      await this.shutdownAgents(active);
+      active.planApproval.destroy();
+      active.messageBus.destroy();
+      this.activeTeams.delete(name);
+    }
+    const teamDir = join(getTeamsDir(), name);
+    if (existsSync(teamDir)) {
+      rmSync(teamDir, { recursive: true, force: true });
+    }
+    const taskDir = join(getTasksDir(), name);
+    if (existsSync(taskDir)) {
+      rmSync(taskDir, { recursive: true, force: true });
+    }
+    getEventBus().emit("team:deleted", { teamName: name });
+    logger.info({ team: name }, "Team deleted");
+  }
+  /** List all teams from disk (active and inactive). */
+  listTeams() {
+    const teamsDir = getTeamsDir();
+    if (!existsSync(teamsDir)) return [];
+    const entries = readdirSync(teamsDir, { withFileTypes: true });
+    const configs = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const teamConfig = this.loadTeamConfig(entry.name);
+        configs.push(teamConfig);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.warn(
+          { team: entry.name, error: reason },
+          "Skipping unreadable team"
+        );
+      }
+    }
+    return configs;
+  }
+  /** Load a team config from disk. Throws if not found. */
+  getTeam(name) {
+    return this.loadTeamConfig(name);
+  }
+  /** Get the runtime state of a specific agent within an active team. */
+  getAgentState(teamName, agentName) {
+    const team = this.activeTeams.get(teamName);
+    if (!team) return void 0;
+    const agentProcess = team.processes.get(agentName);
+    return agentProcess?.getState();
+  }
+  /** Get all agent states for an active team. */
+  getAgentStates(teamName) {
+    const team = this.activeTeams.get(teamName);
+    if (!team) return [];
+    return [...team.processes.values()].map((p) => p.getState());
+  }
+  /** Get the message bus for an active team. */
+  getMessageBus(teamName) {
+    return this.activeTeams.get(teamName)?.messageBus;
+  }
+  /** Get the task store for an active team. */
+  getTaskStore(teamName) {
+    return this.activeTeams.get(teamName)?.taskStore;
+  }
+  /** Get the plan approval handler for an active team. */
+  getPlanApproval(teamName) {
+    return this.activeTeams.get(teamName)?.planApproval;
+  }
+  /** Register a callback for IPC messages from all agents in a team. Returns cleanup function. */
+  onAgentMessages(teamName, callback) {
+    const team = this.getActiveTeam(teamName);
+    const cleanups = [];
+    for (const [agentName, agentProcess] of team.processes) {
+      const unsubscribe = agentProcess.onMessage((method, params) => {
+        callback(agentName, method, params);
+      });
+      cleanups.push(unsubscribe);
+    }
+    return () => {
+      for (const cleanup of cleanups) cleanup();
+    };
+  }
+  /** Assign a task to a specific agent via IPC. */
+  assignTask(teamName, agentName, taskId, subject, description) {
+    const team = this.getActiveTeam(teamName);
+    const agentProcess = team.processes.get(agentName);
+    if (agentProcess) {
+      agentProcess.assignTask(taskId, subject, description);
+    }
+  }
+  /** Check whether a team is currently active in memory. */
+  isTeamActive(name) {
+    return this.activeTeams.has(name);
+  }
+  /** Shut down all active teams. Call during application cleanup. */
+  async shutdownAll() {
+    const names = [...this.activeTeams.keys()];
+    await Promise.allSettled(names.map((n) => this.deleteTeam(n)));
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  getActiveTeam(teamName) {
+    const team = this.activeTeams.get(teamName);
+    if (!team) {
+      throw new Error(`Team not active: ${teamName}`);
+    }
+    return team;
+  }
+  saveTeamConfig(name, config) {
+    const teamDir = join(getTeamsDir(), name);
+    ensureDirectory(teamDir);
+    const serialized = {
+      teamName: config.teamName,
+      description: config.description,
+      status: config.status,
+      members: config.members,
+      createdAt: config.createdAt.toISOString()
+    };
+    const configPath = join(teamDir, "config.json");
+    writeFileSync(configPath, JSON.stringify(serialized, null, 2), {
+      encoding: "utf-8",
+      mode: 420
+    });
+  }
+  loadTeamConfig(name) {
+    const configPath = join(getTeamsDir(), name, "config.json");
+    if (!existsSync(configPath)) {
+      throw new Error(`Team config not found: ${name}`);
+    }
+    const raw = readFileSync(configPath, "utf-8");
+    const data = JSON.parse(raw);
+    return {
+      teamName: data.teamName,
+      description: data.description,
+      status: data.status,
+      members: data.members,
+      createdAt: new Date(data.createdAt)
+    };
+  }
+  async shutdownAgents(team) {
+    const stopPromises = [];
+    for (const [agentName, agentProcess] of team.processes) {
+      stopPromises.push(
+        agentProcess.stop().catch((error) => {
+          const reason = error instanceof Error ? error.message : String(error);
+          logger.error(
+            { agent: agentName, error: reason },
+            "Error stopping agent"
+          );
+        })
+      );
+    }
+    await Promise.allSettled(stopPromises);
+    team.processes.clear();
+  }
+};
+
+export { AgentProcess, MessageBus, PlanApproval, TaskStore, TeamManager };
+//# sourceMappingURL=chunk-HMJRPNPZ.js.map
+//# sourceMappingURL=chunk-HMJRPNPZ.js.map