@oxgeneral/orch 0.2.3 → 0.3.0

package/dist/container-JV7TAUP5.js

@@ -1,1532 +0,0 @@
-#!/usr/bin/env node
-import { DEFAULT_CONFIG } from './chunk-ED47GL3F.js';
-import { isGoalTerminal, GOAL_STATUS_ORDER } from './chunk-HXYAZGLP.js';
-import { canTransition, isTerminal } from './chunk-33QNTNR6.js';
-import { AUTONOMOUS_LABEL } from './chunk-PNE6LQRF.js';
-import { readLines } from './chunk-CHIP7O6V.js';
-import { Paths, readYaml, writeYaml, ensureDir, listFiles, writeJson, readJson, appendJsonl, readJsonl, readJsonlTail, pathExists } from './chunk-VTA74YWX.js';
-import { InvalidArgumentsError, TeamNotFoundError, GoalNotFoundError, AgentNotFoundError, TaskNotFoundError, InvalidTransitionError } from './chunk-O5AO5QIR.js';
-import fs, { mkdir } from 'fs/promises';
-import { createReadStream } from 'fs';
-import path from 'path';
-import { homedir } from 'os';
-import { nanoid } from 'nanoid';
-
-var TaskStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async list(filter) {
-    await ensureDir(this.paths.tasksDir);
-    const files = await listFiles(this.paths.tasksDir, ".yml");
-    const tasksResults = await Promise.all(
-      files.map((file) => {
-        const id = file.replace(".yml", "");
-        return readYaml(this.paths.taskPath(id));
-      })
-    );
-    const tasks = tasksResults.filter(
-      (task) => task !== null && (!filter?.status || task.status === filter.status)
-    );
-    return tasks.sort((a, b) => {
-      const statusOrder = statusPriority(a.status) - statusPriority(b.status);
-      if (statusOrder !== 0) return statusOrder;
-      const bTime = b.updated_at ?? "";
-      const aTime = a.updated_at ?? "";
-      return bTime < aTime ? -1 : bTime > aTime ? 1 : 0;
-    });
-  }
-  async get(id) {
-    return readYaml(this.paths.taskPath(id));
-  }
-  async save(task) {
-    await ensureDir(this.paths.tasksDir);
-    await writeYaml(this.paths.taskPath(task.id), task);
-  }
-  async delete(id) {
-    try {
-      await fs.unlink(this.paths.taskPath(id));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-};
-function statusPriority(status) {
-  const order = {
-    in_progress: 0,
-    retrying: 1,
-    review: 2,
-    todo: 3,
-    done: 4,
-    failed: 5,
-    cancelled: 6
-  };
-  return order[status];
-}
-var AgentStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async list() {
-    await ensureDir(this.paths.agentsDir);
-    const files = await listFiles(this.paths.agentsDir, ".yml");
-    const results = await Promise.all(
-      files.map((file) => {
-        const id = file.replace(".yml", "");
-        return readYaml(this.paths.agentPath(id));
-      })
-    );
-    return results.filter((agent) => agent !== null);
-  }
-  async get(id) {
-    return readYaml(this.paths.agentPath(id));
-  }
-  async getByName(name) {
-    const agents = await this.list();
-    return agents.find((a) => a.name === name) ?? null;
-  }
-  async save(agent) {
-    await ensureDir(this.paths.agentsDir);
-    await writeYaml(this.paths.agentPath(agent.id), agent);
-  }
-  async delete(id) {
-    try {
-      await fs.unlink(this.paths.agentPath(id));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-};
-var RunStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async save(run) {
-    await ensureDir(this.paths.runsDir);
-    await writeJson(this.paths.runPath(run.id), run);
-  }
-  async get(id) {
-    return readJson(this.paths.runPath(id));
-  }
-  async listAll() {
-    return this.listFiltered(() => true);
-  }
-  async listForTask(taskId) {
-    return this.listFiltered((run) => run.task_id === taskId);
-  }
-  async listForAgent(agentId) {
-    return this.listFiltered((run) => run.agent_id === agentId);
-  }
-  async appendEvent(runId, event) {
-    await ensureDir(this.paths.runsDir);
-    await appendJsonl(this.paths.runEventsPath(runId), event);
-  }
-  async readEvents(runId) {
-    return readJsonl(this.paths.runEventsPath(runId));
-  }
-  /**
-   * Read the last N events for a run without loading the entire JSONL file.
-   */
-  async readEventsTail(runId, count) {
-    return readJsonlTail(this.paths.runEventsPath(runId), count);
-  }
-  async *streamEvents(runId, signal) {
-    const filePath = this.paths.runEventsPath(runId);
-    const deadline = Date.now() + 3e4;
-    while (!signal?.aborted && Date.now() < deadline) {
-      if (await pathExists(filePath)) break;
-      await new Promise((r) => setTimeout(r, 100));
-    }
-    if (signal?.aborted || Date.now() >= deadline) return;
-    const stream = createReadStream(filePath);
-    try {
-      for await (const line of readLines(stream)) {
-        if (signal?.aborted) break;
-        if (line.trim()) {
-          try {
-            yield JSON.parse(line);
-          } catch {
-            process.stderr.write(`[RunStore] skipping corrupt JSONL line: ${line.slice(0, 200)}
-`);
-          }
-        }
-      }
-    } finally {
-      stream.destroy();
-    }
-  }
-  async listFiltered(predicate) {
-    await ensureDir(this.paths.runsDir);
-    const files = await listFiles(this.paths.runsDir, ".json");
-    const BATCH = 64;
-    const all = [];
-    for (let i = 0; i < files.length; i += BATCH) {
-      const batch = files.slice(i, i + BATCH);
-      const results = await Promise.all(
-        batch.map((file) => {
-          const id = file.endsWith(".json") ? file.slice(0, -5) : file;
-          return readJson(this.paths.runPath(id));
-        })
-      );
-      for (const run of results) {
-        if (run !== null && predicate(run)) all.push(run);
-      }
-    }
-    return all.sort(
-      (a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime()
-    );
-  }
-};
-
-// src/domain/state.ts
-var DEFAULT_STATE = {
-  version: 1,
-  running: {},
-  claimed: [],
-  retry_queue: [],
-  stats: {
-    total_runs: 0,
-    total_tasks_completed: 0,
-    total_tasks_failed: 0,
-    total_tokens: { input: 0, output: 0, total: 0 },
-    total_runtime_ms: 0
-  }
-};
-
-// src/infrastructure/storage/state-store.ts
-var StateStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async read() {
-    const raw = await readJson(this.paths.statePath);
-    if (!raw) return structuredClone(DEFAULT_STATE);
-    const defaults = structuredClone(DEFAULT_STATE);
-    return {
-      version: raw.version ?? defaults.version,
-      pid: raw.pid,
-      started_at: raw.started_at,
-      running: raw.running && typeof raw.running === "object" ? raw.running : defaults.running,
-      claimed: Array.isArray(raw.claimed) ? raw.claimed : defaults.claimed,
-      retry_queue: Array.isArray(raw.retry_queue) ? raw.retry_queue : defaults.retry_queue,
-      stats: {
-        total_runs: raw.stats?.total_runs ?? defaults.stats.total_runs,
-        total_tasks_completed: raw.stats?.total_tasks_completed ?? defaults.stats.total_tasks_completed,
-        total_tasks_failed: raw.stats?.total_tasks_failed ?? defaults.stats.total_tasks_failed,
-        total_tokens: raw.stats?.total_tokens ?? defaults.stats.total_tokens,
-        total_runtime_ms: raw.stats?.total_runtime_ms ?? defaults.stats.total_runtime_ms
-      }
-    };
-  }
-  async write(state) {
-    await writeJson(this.paths.statePath, state);
-  }
-};
-
-// src/infrastructure/storage/config-store.ts
-var ConfigStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async read() {
-    const config = await readYaml(this.paths.configPath);
-    return deepMerge(
-      DEFAULT_CONFIG,
-      config ?? {}
-    );
-  }
-  async write(config) {
-    await writeYaml(this.paths.configPath, config);
-  }
-  async get(keyPath) {
-    const config = await this.read();
-    return getByPath(config, keyPath);
-  }
-  async set(keyPath, value) {
-    const config = await this.read();
-    setByPath(config, keyPath, value);
-    await this.write(config);
-  }
-};
-function getByPath(obj, keyPath) {
-  const keys = keyPath.split(".");
-  let current = obj;
-  for (const key of keys) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[key];
-  }
-  return current;
-}
-function setByPath(obj, keyPath, value) {
-  const keys = keyPath.split(".");
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (typeof current[key] !== "object" || current[key] === null) {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-  const lastKey = keys[keys.length - 1];
-  current[lastKey] = value;
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceVal = source[key];
-    const targetVal = result[key];
-    if (sourceVal !== null && sourceVal !== void 0 && typeof sourceVal === "object" && !Array.isArray(sourceVal) && typeof targetVal === "object" && targetVal !== null && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(
-        targetVal,
-        sourceVal
-      );
-    } else {
-      result[key] = sourceVal;
-    }
-  }
-  return result;
-}
-
-// src/domain/global-config.ts
-var DEFAULT_GLOBAL_CONFIG = {
-  tui: {
-    activity_filter: "all"
-  }
-};
-
-// src/infrastructure/storage/global-config-store.ts
-var GLOBAL_DIR = path.join(homedir(), ".orchestry");
-var GLOBAL_CONFIG_PATH = path.join(GLOBAL_DIR, "global.yml");
-var GlobalConfigStore = class {
-  async read() {
-    const data = await readYaml(GLOBAL_CONFIG_PATH);
-    if (!data) return { ...DEFAULT_GLOBAL_CONFIG };
-    return {
-      tui: {
-        activity_filter: data.tui?.activity_filter ?? DEFAULT_GLOBAL_CONFIG.tui.activity_filter
-      }
-    };
-  }
-  async write(config) {
-    await mkdir(GLOBAL_DIR, { recursive: true });
-    await writeYaml(GLOBAL_CONFIG_PATH, config);
-  }
-  async set(key, value) {
-    const config = await this.read();
-    config.tui[key] = value;
-    await this.write(config);
-  }
-};
-var ContextStore = class _ContextStore {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async get(key) {
-    const entry = await readJson(this.paths.contextPath(key));
-    if (!entry) return null;
-    if (isExpired(entry)) {
-      await this.delete(key);
-      return null;
-    }
-    return entry;
-  }
-  /** Max TTL: 30 days in milliseconds */
-  static MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-  async set(key, value, ttlMs) {
-    if (ttlMs !== void 0) {
-      if (!Number.isFinite(ttlMs) || ttlMs <= 0 || ttlMs > _ContextStore.MAX_TTL_MS) {
-        throw new Error(`TTL must be a positive number up to ${_ContextStore.MAX_TTL_MS}ms (30 days)`);
-      }
-    }
-    await ensureDir(this.paths.contextDir);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = await readJson(this.paths.contextPath(key));
-    const entry = {
-      key,
-      value,
-      created_at: existing?.created_at ?? now,
-      updated_at: now,
-      ttl_ms: ttlMs,
-      expires_at: ttlMs ? new Date(Date.now() + ttlMs).toISOString() : void 0
-    };
-    await writeJson(this.paths.contextPath(key), entry);
-  }
-  async delete(key) {
-    try {
-      await fs.unlink(this.paths.contextPath(key));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-  async list() {
-    await ensureDir(this.paths.contextDir);
-    const files = await listFiles(this.paths.contextDir, ".json");
-    const results = await Promise.all(
-      files.map((file) => {
-        const key = file.replace(".json", "");
-        return readJson(this.paths.contextPath(key));
-      })
-    );
-    const entries = [];
-    for (const entry of results) {
-      if (!entry) continue;
-      if (isExpired(entry)) {
-        await this.delete(entry.key);
-        continue;
-      }
-      entries.push(entry);
-    }
-    return entries.sort((a, b) => a.key.localeCompare(b.key));
-  }
-  async getAll() {
-    const entries = await this.list();
-    const result = {};
-    for (const entry of entries) {
-      result[entry.key] = entry.value;
-    }
-    return result;
-  }
-};
-function isExpired(entry) {
-  if (!entry.expires_at) return false;
-  return new Date(entry.expires_at).getTime() < Date.now();
-}
-var MessageStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async save(message) {
-    await ensureDir(this.paths.messagesDir);
-    await writeJson(this.paths.messagePath(message.id), message);
-  }
-  async get(id) {
-    return readJson(this.paths.messagePath(id));
-  }
-  async list() {
-    const files = await listFiles(this.paths.messagesDir, ".json");
-    const results = await Promise.all(
-      files.map((f) => readJson(this.paths.messagePath(f.replace(".json", ""))))
-    );
-    return results.filter((m) => m !== null).sort((a, b) => a.created_at.localeCompare(b.created_at));
-  }
-  async listPending(agentId) {
-    const all = await this.list();
-    const now = Date.now();
-    return all.filter((m) => {
-      if (m.status !== "pending") return false;
-      if (m.expires_at && new Date(m.expires_at).getTime() < now) return false;
-      return m.to_agent_id === agentId;
-    });
-  }
-  async markDelivered(id) {
-    const msg = await this.get(id);
-    if (!msg) return;
-    msg.status = "delivered";
-    msg.delivered_at = (/* @__PURE__ */ new Date()).toISOString();
-    await writeJson(this.paths.messagePath(id), msg);
-  }
-  async delete(id) {
-    try {
-      await fs.unlink(this.paths.messagePath(id));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-  async purgeExpired() {
-    const all = await this.list();
-    const now = Date.now();
-    const toDelete = all.filter((m) => {
-      const isExpired2 = m.expires_at && new Date(m.expires_at).getTime() < now;
-      const isOldDelivered = m.delivered_at && now - new Date(m.delivered_at).getTime() > 36e5;
-      return isExpired2 || isOldDelivered;
-    });
-    await Promise.all(toDelete.map((m) => this.delete(m.id)));
-    return toDelete.length;
-  }
-};
-var GoalStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async list(filter) {
-    const files = await listFiles(this.paths.goalsDir, ".yml");
-    const results = await Promise.all(
-      files.map((file) => {
-        const id = file.replace(".yml", "");
-        return readYaml(this.paths.goalPath(id));
-      })
-    );
-    const goals = results.filter(
-      (goal) => goal !== null && (!filter?.status || goal.status === filter.status)
-    );
-    return goals.sort((a, b) => {
-      const statusOrder = GOAL_STATUS_ORDER[a.status] - GOAL_STATUS_ORDER[b.status];
-      if (statusOrder !== 0) return statusOrder;
-      const bTime = b.updated_at ?? "";
-      const aTime = a.updated_at ?? "";
-      return bTime < aTime ? -1 : bTime > aTime ? 1 : 0;
-    });
-  }
-  async get(id) {
-    return readYaml(this.paths.goalPath(id));
-  }
-  async save(goal) {
-    await writeYaml(this.paths.goalPath(goal.id), goal);
-  }
-  async delete(id) {
-    try {
-      await fs.unlink(this.paths.goalPath(id));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-};
-var TeamStore = class {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  async save(team) {
-    await ensureDir(this.paths.teamsDir);
-    await writeYaml(this.paths.teamPath(team.id), team);
-  }
-  async get(id) {
-    return readYaml(this.paths.teamPath(id));
-  }
-  async getByName(name) {
-    const teams = await this.list();
-    return teams.find((t) => t.name === name) ?? null;
-  }
-  async list() {
-    await ensureDir(this.paths.teamsDir);
-    const files = await listFiles(this.paths.teamsDir, ".yml");
-    const results = await Promise.all(
-      files.map((f) => readYaml(this.paths.teamPath(f.replace(".yml", ""))))
-    );
-    return results.filter((t) => t !== null);
-  }
-  async delete(id) {
-    try {
-      await fs.unlink(this.paths.teamPath(id));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-};
-
-// src/application/event-bus.ts
-var EventBus = class {
-  handlers = /* @__PURE__ */ new Map();
-  wildcardHandlers = /* @__PURE__ */ new Set();
-  maxListeners = 10;
-  warnedTypes = /* @__PURE__ */ new Set();
-  /**
-   * Set the maximum number of listeners per event type before a warning is emitted.
-   * Helps detect memory leaks from repeated subscriptions in watch mode.
-   */
-  setMaxListeners(n) {
-    this.maxListeners = n;
-  }
-  getMaxListeners() {
-    return this.maxListeners;
-  }
-  /**
-   * Get the number of listeners for a specific event type.
-   */
-  listenerCount(type) {
-    return this.handlers.get(type)?.size ?? 0;
-  }
-  /**
-   * Subscribe to events of a specific type.
-   * Returns an unsubscribe function.
-   */
-  on(type, handler) {
-    if (!this.handlers.has(type)) {
-      this.handlers.set(type, /* @__PURE__ */ new Set());
-    }
-    const set = this.handlers.get(type);
-    set.add(handler);
-    if (this.maxListeners > 0 && set.size > this.maxListeners && !this.warnedTypes.has(type)) {
-      this.warnedTypes.add(type);
-      console.warn(
-        `EventBus: possible memory leak detected. ${set.size} listeners added for "${type}". Use setMaxListeners() to increase limit if this is intentional.`
-      );
-    }
-    return () => this.off(type, handler);
-  }
-  /**
-   * Subscribe to an event type, auto-unsubscribe after first call.
-   */
-  once(type, handler) {
-    const wrapper = (event) => {
-      this.off(type, wrapper);
-      handler(event);
-    };
-    return this.on(type, wrapper);
-  }
-  /**
-   * Unsubscribe a handler from an event type.
-   */
-  off(type, handler) {
-    this.handlers.get(type)?.delete(handler);
-  }
-  /**
-   * Emit an event synchronously to all subscribed handlers.
-   */
-  emit(event) {
-    const typed = this.handlers.get(event.type);
-    if (typed) this.dispatchToSet(typed, event, "handler");
-    this.dispatchToSet(this.wildcardHandlers, event, "wildcard handler");
-  }
-  dispatchToSet(handlers, event, label) {
-    for (const handler of handlers) {
-      try {
-        handler(event);
-      } catch (err) {
-        console.error(`EventBus ${label} error for "${event.type}":`, err);
-      }
-    }
-  }
-  /**
-   * Subscribe to ALL events regardless of type.
-   */
-  onAny(handler) {
-    this.wildcardHandlers.add(handler);
-    if (this.maxListeners > 0 && this.wildcardHandlers.size > this.maxListeners && !this.warnedTypes.has("*")) {
-      this.warnedTypes.add("*");
-      console.warn(
-        `EventBus: possible memory leak detected. ${this.wildcardHandlers.size} wildcard listeners added. Use setMaxListeners() to increase limit if this is intentional.`
-      );
-    }
-    return () => {
-      this.wildcardHandlers.delete(handler);
-    };
-  }
-  /**
-   * Remove all handlers.
-   */
-  clear() {
-    this.handlers.clear();
-    this.wildcardHandlers.clear();
-    this.warnedTypes.clear();
-  }
-};
-var TaskService = class {
-  constructor(taskStore, eventBus, config) {
-    this.taskStore = taskStore;
-    this.eventBus = eventBus;
-    this.config = config;
-  }
-  async create(input) {
-    if (!input.title.trim()) {
-      throw new InvalidArgumentsError("Task title is required");
-    }
-    const priority = input.priority ?? this.config.defaults.task.priority;
-    if (!Number.isInteger(priority) || priority < 1 || priority > 4) {
-      throw new InvalidArgumentsError("Priority must be an integer between 1 and 4");
-    }
-    if (input.depends_on?.length) {
-      const results = await Promise.all(
-        input.depends_on.map(async (depId) => ({ depId, exists: !!await this.taskStore.get(depId) }))
-      );
-      const missing = results.filter((r) => !r.exists).map((r) => r.depId);
-      if (missing.length > 0) {
-        throw new InvalidArgumentsError(
-          `Unknown depends_on task ID(s): ${missing.join(", ")}`
-        );
-      }
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const task = {
-      id: `tsk_${nanoid(7)}`,
-      title: input.title.trim(),
-      description: input.description?.trim() ?? "",
-      status: "todo",
-      priority,
-      assignee: input.assignee,
-      labels: input.labels ?? [],
-      depends_on: input.depends_on ?? [],
-      created_at: now,
-      updated_at: now,
-      attempts: 0,
-      max_attempts: input.max_attempts ?? this.config.defaults.task.max_attempts,
-      workspace_mode: input.workspace_mode,
-      review_criteria: input.review_criteria,
-      scope: input.scope
-    };
-    await this.taskStore.save(task);
-    this.eventBus.emit({ type: "task:created", task });
-    return task;
-  }
-  async list(filter) {
-    return this.taskStore.list(filter);
-  }
-  async get(id) {
-    const task = await this.taskStore.get(id);
-    if (!task) throw new TaskNotFoundError(id);
-    return task;
-  }
-  async updateStatus(id, newStatus) {
-    const task = await this.get(id);
-    const oldStatus = task.status;
-    if (!canTransition(oldStatus, newStatus)) {
-      throw new InvalidTransitionError(id, oldStatus, newStatus);
-    }
-    task.status = newStatus;
-    task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.taskStore.save(task);
-    this.eventBus.emit({
-      type: "task:status_changed",
-      taskId: id,
-      from: oldStatus,
-      to: newStatus
-    });
-    return task;
-  }
-  async assign(taskId, agentId) {
-    const task = await this.get(taskId);
-    task.assignee = agentId;
-    task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.taskStore.save(task);
-    this.eventBus.emit({
-      type: "task:assigned",
-      taskId,
-      agentId
-    });
-    return task;
-  }
-  async cancel(id) {
-    const task = await this.get(id);
-    if (isTerminal(task.status)) {
-      throw new InvalidTransitionError(id, task.status, "cancelled");
-    }
-    return this.updateStatus(id, "cancelled");
-  }
-  async retry(id) {
-    const task = await this.get(id);
-    if (task.status !== "failed" && task.status !== "cancelled") {
-      throw new InvalidTransitionError(id, task.status, "todo");
-    }
-    const oldStatus = task.status;
-    task.status = "todo";
-    task.attempts = 0;
-    task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.taskStore.save(task);
-    this.eventBus.emit({
-      type: "task:status_changed",
-      taskId: id,
-      from: oldStatus,
-      to: "todo"
-    });
-    return task;
-  }
-  async reject(id, feedback) {
-    const task = await this.get(id);
-    if (task.status !== "review") {
-      throw new InvalidTransitionError(id, task.status, "todo");
-    }
-    const oldStatus = task.status;
-    task.status = "todo";
-    task.attempts = 0;
-    task.feedback = feedback;
-    task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.taskStore.save(task);
-    this.eventBus.emit({
-      type: "task:status_changed",
-      taskId: id,
-      from: oldStatus,
-      to: "todo"
-    });
-    return task;
-  }
-  async update(id, fields) {
-    const task = await this.get(id);
-    if (fields.title !== void 0) {
-      if (!fields.title.trim()) throw new InvalidArgumentsError("Task title cannot be empty");
-      task.title = fields.title.trim();
-    }
-    if (fields.description !== void 0) task.description = fields.description.trim();
-    if (fields.priority !== void 0) {
-      if (!Number.isInteger(fields.priority) || fields.priority < 1 || fields.priority > 4) {
-        throw new InvalidArgumentsError("Priority must be an integer between 1 and 4");
-      }
-      task.priority = fields.priority;
-    }
-    if (fields.labels !== void 0) task.labels = fields.labels;
-    task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.taskStore.save(task);
-    return task;
-  }
-  async delete(id) {
-    const task = await this.get(id);
-    if (task.status === "in_progress") {
-      throw new InvalidArgumentsError("Cannot delete a running task. Cancel it first.");
-    }
-    await this.taskStore.delete(id);
-  }
-  async incrementAttempts(id) {
-    const task = await this.get(id);
-    task.attempts += 1;
-    task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.taskStore.save(task);
-    return task;
-  }
-};
-var AgentService = class {
-  constructor(agentStore, stateStore, eventBus, config) {
-    this.agentStore = agentStore;
-    this.stateStore = stateStore;
-    this.eventBus = eventBus;
-    this.config = config;
-  }
-  async create(input) {
-    if (!input.name.trim()) {
-      throw new InvalidArgumentsError("Agent name is required");
-    }
-    const existing = await this.agentStore.getByName(input.name);
-    if (existing) {
-      throw new InvalidArgumentsError(`Agent "${input.name}" already exists`);
-    }
-    const agent = {
-      id: `agt_${nanoid(7)}`,
-      name: input.name.trim(),
-      adapter: input.adapter || this.config.defaults.agent.adapter,
-      role: input.role,
-      config: {
-        command: input.command,
-        model: input.model,
-        approval_policy: input.approval_policy ?? this.config.defaults.agent.approval_policy,
-        max_turns: input.max_turns ?? this.config.defaults.agent.max_turns,
-        timeout_ms: input.timeout_ms ?? this.config.defaults.agent.timeout_ms,
-        stall_timeout_ms: input.stall_timeout_ms ?? this.config.defaults.agent.stall_timeout_ms,
-        env: input.env,
-        system_prompt: input.system_prompt,
-        workspace_mode: input.workspace_mode,
-        skills: input.skills
-      },
-      status: "idle",
-      stats: {
-        tasks_completed: 0,
-        tasks_failed: 0,
-        total_runs: 0,
-        total_runtime_ms: 0
-      }
-    };
-    await this.agentStore.save(agent);
-    return agent;
-  }
-  async list() {
-    return this.agentStore.list();
-  }
-  async get(id) {
-    const agent = await this.agentStore.get(id);
-    if (!agent) throw new AgentNotFoundError(id);
-    return agent;
-  }
-  async remove(id) {
-    const agent = await this.get(id);
-    if (agent.status === "running") {
-      const state = await this.stateStore.read();
-      const isActuallyRunning = Object.values(state.running).some((e) => e.agent_id === id);
-      if (isActuallyRunning) {
-        throw new InvalidArgumentsError("Cannot remove a running agent. Stop it first.");
-      }
-      agent.status = "idle";
-      await this.agentStore.save(agent);
-    }
-    await this.agentStore.delete(id);
-  }
-  async update(id, fields) {
-    const agent = await this.get(id);
-    if (fields.name !== void 0) {
-      if (!fields.name.trim()) throw new InvalidArgumentsError("Agent name cannot be empty");
-      const existing = await this.agentStore.getByName(fields.name.trim());
-      if (existing && existing.id !== id) {
-        throw new InvalidArgumentsError(`Agent "${fields.name}" already exists`);
-      }
-      agent.name = fields.name.trim();
-    }
-    if (fields.role !== void 0) agent.role = fields.role || void 0;
-    if (fields.model !== void 0) agent.config.model = fields.model || void 0;
-    if (fields.approval_policy !== void 0) agent.config.approval_policy = fields.approval_policy;
-    await this.agentStore.save(agent);
-    return agent;
-  }
-  async disable(id) {
-    return this.setStatus(id, "disabled");
-  }
-  async enable(id) {
-    return this.setStatus(id, "idle");
-  }
-  async setAutonomous(id, enabled) {
-    const agent = await this.get(id);
-    agent.autonomous = enabled;
-    await this.agentStore.save(agent);
-    this.eventBus.emit({ type: "agent:autonomous_toggled", agentId: id, autonomous: enabled });
-    return agent;
-  }
-  async setStatus(id, status) {
-    const agent = await this.get(id);
-    agent.status = status;
-    await this.agentStore.save(agent);
-    return agent;
-  }
-  async updateStats(id, update) {
-    const agent = await this.get(id);
-    Object.assign(agent.stats, update);
-    await this.agentStore.save(agent);
-    return agent;
-  }
-  /**
-   * Find the best available agent for a task using scoring.
-   *
-   * Scoring:
-   * - Explicit assignee match = 100
-   * - Skill match with task labels = 50 per match
-   * - Role match with task labels = 30
-   * - Idle status bonus = 20
-   * - Success rate bonus = 0–10 (scaled by completed / total)
-   */
-  async findBestAgent(task) {
-    const agents = await this.agentStore.list();
-    const available = agents.filter(
-      (a) => a.status === "idle"
-    );
-    if (available.length === 0) return null;
-    if (task.assignee) {
-      const assigned = agents.find((a) => a.id === task.assignee);
-      if (assigned && assigned.status === "idle") return assigned;
-      return null;
-    }
-    const scored = available.map((agent) => {
-      let score = 0;
-      if (task.labels?.length > 0 && agent.config.skills?.length) {
-        for (const label of task.labels) {
-          const lowerLabel = label.toLowerCase();
-          if (agent.config.skills.some((s) => s.toLowerCase() === lowerLabel)) {
-            score += 50;
-          }
-        }
-      }
-      if (task.labels?.length > 0 && agent.role) {
-        const lowerRole = agent.role.toLowerCase();
-        if (task.labels.some((l) => lowerRole.includes(l.toLowerCase()))) {
-          score += 30;
-        }
-      }
-      if (agent.status === "idle") {
-        score += 20;
-      }
-      const totalTasks = agent.stats.tasks_completed + agent.stats.tasks_failed;
-      if (totalTasks > 0) {
-        score += Math.round(agent.stats.tasks_completed / totalTasks * 10);
-      }
-      return { agent, score };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    return scored[0]?.agent ?? null;
-  }
-};
-var RunService = class {
-  constructor(runStore, eventBus) {
-    this.runStore = runStore;
-    this.eventBus = eventBus;
-  }
-  async create(params) {
-    const run = {
-      id: `run_${nanoid(7)}`,
-      task_id: params.taskId,
-      agent_id: params.agentId,
-      attempt: params.attempt,
-      status: "preparing",
-      started_at: (/* @__PURE__ */ new Date()).toISOString(),
-      workspace_path: params.workspacePath,
-      prompt: params.prompt
-    };
-    await this.runStore.save(run);
-    return run;
-  }
-  async get(id) {
-    return this.runStore.get(id);
-  }
-  async start(id, pid) {
-    const run = await this.runStore.get(id);
-    if (!run) throw new Error(`Run not found: ${id}`);
-    run.status = "running";
-    run.pid = pid;
-    await this.runStore.save(run);
-    this.eventBus.emit({
-      type: "agent:started",
-      agentId: run.agent_id,
-      taskId: run.task_id,
-      runId: id
-    });
-    return run;
-  }
-  async finish(id, status, tokens, error) {
-    const run = await this.runStore.get(id);
-    if (!run) throw new Error(`Run not found: ${id}`);
-    run.status = status;
-    run.finished_at = (/* @__PURE__ */ new Date()).toISOString();
-    run.tokens = tokens;
-    run.error = error;
-    await this.runStore.save(run);
-    this.eventBus.emit({
-      type: "agent:completed",
-      runId: id,
-      agentId: run.agent_id,
-      success: status === "succeeded"
-    });
-    return run;
-  }
-  async appendEvent(runId, event) {
-    await this.runStore.appendEvent(runId, event);
-  }
-  async listAll() {
-    return this.runStore.listAll();
-  }
-  async listForTask(taskId) {
-    return this.runStore.listForTask(taskId);
-  }
-  async listForAgent(agentId) {
-    return this.runStore.listForAgent(agentId);
-  }
-  async readEvents(runId) {
-    return this.runStore.readEvents(runId);
-  }
-  async readEventsTail(runId, count) {
-    return this.runStore.readEventsTail(runId, count);
-  }
-  /**
-   * Get error and last N lines of output from the most recent failed run for a task.
-   * Used to provide retry context so agents can learn from previous failures.
-   */
-  async getLastFailedRunContext(taskId, maxOutputLines = 50) {
-    const runs = await this.runStore.listForTask(taskId);
-    const failedRun = runs.filter((r) => r.status === "failed").sort((a, b) => (b.finished_at ?? "").localeCompare(a.finished_at ?? ""))[0];
-    if (!failedRun) return null;
-    const error = failedRun.error ?? "Unknown error";
-    let output = "";
-    try {
-      const events = await this.runStore.readEventsTail(failedRun.id, maxOutputLines * 2);
-      const outputLines = events.filter((e) => e.type === "agent_output" || e.type === "error").map((e) => typeof e.data === "string" ? e.data : JSON.stringify(e.data)).join("\n").split("\n");
-      output = outputLines.slice(-maxOutputLines).join("\n");
-    } catch {
-    }
-    return { error, output };
-  }
-};
-
-// src/domain/message.ts
-var MAX_MESSAGE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var DEFAULT_MESSAGE_TTL_MS = 24 * 60 * 60 * 1e3;
-
-// src/application/message-service.ts
-var MessageService = class {
-  constructor(messageStore, agentStore, teamStore, eventBus) {
-    this.messageStore = messageStore;
-    this.agentStore = agentStore;
-    this.teamStore = teamStore;
-    this.eventBus = eventBus;
-  }
-  /**
-   * Send a message. For broadcast, creates one message per recipient agent.
-   * For 'lead' channel, resolves team lead and sends direct.
-   */
-  async send(input) {
-    if (!input.body.trim()) throw new InvalidArgumentsError("Message body is required");
-    const ttlMs = input.ttl_ms ?? DEFAULT_MESSAGE_TTL_MS;
-    if (ttlMs <= 0 || ttlMs > MAX_MESSAGE_TTL_MS) {
-      throw new InvalidArgumentsError(`TTL must be between 1ms and ${MAX_MESSAGE_TTL_MS}ms`);
-    }
-    const sender = await this.agentStore.get(input.from_agent_id);
-    if (!sender && input.from_agent_id !== "cli") {
-      throw new InvalidArgumentsError(`Sender agent not found: ${input.from_agent_id}`);
-    }
-    const now = /* @__PURE__ */ new Date();
-    const baseMessage = {
-      channel: input.channel,
-      from_agent_id: input.from_agent_id,
-      subject: (input.subject || "(no subject)").slice(0, 200),
-      body: input.body.slice(0, 4e3),
-      created_at: now.toISOString(),
-      expires_at: new Date(now.getTime() + ttlMs).toISOString(),
-      status: "pending",
-      team_id: input.team_id,
-      reply_to: input.reply_to
-    };
-    const messages = [];
-    if (input.channel === "broadcast") {
-      let agents = await this.agentStore.list();
-      if (input.team_id) {
-        const team = await this.teamStore.get(input.team_id);
-        if (team) {
-          const memberIds = new Set(team.members.map((m) => m.agent_id));
-          agents = agents.filter((a) => memberIds.has(a.id));
-        }
-      }
-      const recipients = agents.filter((a) => a.id !== input.from_agent_id && a.status !== "disabled");
-      const broadcastMsgs = recipients.map((agent) => ({
-        ...baseMessage,
-        id: `msg_${nanoid(7)}`,
-        to_agent_id: agent.id
-      }));
-      await Promise.all(broadcastMsgs.map((msg) => this.messageStore.save(msg)));
-      for (const msg of broadcastMsgs) {
-        messages.push(msg);
-        this.emitSent(msg);
-      }
-    } else if (input.channel === "lead") {
-      if (!input.team_id) throw new InvalidArgumentsError("team_id is required for lead channel");
-      const team = await this.teamStore.get(input.team_id);
-      if (!team) throw new InvalidArgumentsError(`Team not found: ${input.team_id}`);
-      const msg = {
-        ...baseMessage,
-        id: `msg_${nanoid(7)}`,
-        to_agent_id: team.lead_agent_id
-      };
-      await this.messageStore.save(msg);
-      messages.push(msg);
-      this.emitSent(msg);
-    } else {
-      if (!input.to_agent_id) throw new InvalidArgumentsError("to_agent_id is required for direct messages");
-      const recipient = await this.agentStore.get(input.to_agent_id);
-      if (!recipient) throw new InvalidArgumentsError(`Recipient agent not found: ${input.to_agent_id}`);
-      const msg = {
-        ...baseMessage,
-        id: `msg_${nanoid(7)}`,
-        to_agent_id: input.to_agent_id
-      };
-      await this.messageStore.save(msg);
-      messages.push(msg);
-      this.emitSent(msg);
-    }
-    return messages;
-  }
-  /**
-   * Drain mailbox: fetch pending messages for an agent and mark them delivered.
-   * Called by the orchestrator during dispatchTask.
-   */
-  async drainMailbox(agentId, taskId) {
-    const pending = await this.messageStore.listPending(agentId);
-    await Promise.all(pending.map((msg) => this.messageStore.markDelivered(msg.id)));
-    for (const msg of pending) {
-      this.eventBus.emit({
-        type: "message:delivered",
-        messageId: msg.id,
-        toAgentId: agentId,
-        taskId
-      });
-    }
-    return pending;
-  }
-  async listAll() {
-    return this.messageStore.list();
-  }
-  async listPendingForAgent(agentId) {
-    return this.messageStore.listPending(agentId);
-  }
-  async listForAgent(agentId) {
-    const all = await this.messageStore.list();
-    return all.filter((m) => m.to_agent_id === agentId || m.from_agent_id === agentId);
-  }
-  async purgeExpired() {
-    return this.messageStore.purgeExpired();
-  }
-  emitSent(msg) {
-    this.eventBus.emit({
-      type: "message:sent",
-      messageId: msg.id,
-      fromAgentId: msg.from_agent_id,
-      toAgentId: msg.to_agent_id,
-      channel: msg.channel
-    });
-  }
-};
-var VALID_TRANSITIONS = {
-  active: ["paused", "achieved", "abandoned"],
-  paused: ["active", "abandoned"],
-  achieved: [],
-  abandoned: []
-};
-var GoalService = class {
-  constructor(goalStore, eventBus, agentService, taskService) {
-    this.goalStore = goalStore;
-    this.eventBus = eventBus;
-    this.agentService = agentService;
-    this.taskService = taskService;
-  }
-  async create(input) {
-    if (!input.title.trim()) {
-      throw new InvalidArgumentsError("Goal title is required");
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const goal = {
-      id: `goal_${nanoid(7)}`,
-      title: input.title.trim(),
-      description: input.description?.trim() ?? "",
-      status: "active",
-      assignee: input.assignee,
-      created_at: now,
-      updated_at: now
-    };
-    await this.goalStore.save(goal);
-    this.eventBus.emit({ type: "goal:created", goalId: goal.id, title: goal.title });
-    if (goal.assignee) {
-      await this.enableAutonomous(goal.assignee);
-    }
-    return goal;
-  }
-  async list(filter) {
-    return this.goalStore.list(filter);
-  }
-  async get(id) {
-    const goal = await this.goalStore.get(id);
-    if (!goal) throw new GoalNotFoundError(id);
-    return goal;
-  }
-  async updateStatus(id, newStatus) {
-    const goal = await this.get(id);
-    const oldStatus = goal.status;
-    if (!VALID_TRANSITIONS[oldStatus].includes(newStatus)) {
-      throw new InvalidArgumentsError(
-        `Cannot transition goal from '${oldStatus}' to '${newStatus}'`
-      );
-    }
-    goal.status = newStatus;
-    goal.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.goalStore.save(goal);
-    this.eventBus.emit({ type: "goal:status_changed", goalId: id, from: oldStatus, to: newStatus });
-    if (goal.assignee) {
-      if (newStatus === "paused") {
-        await this.maybeDisableAutonomous(goal.assignee);
-        await this.cancelPendingAutonomousTasks(goal.assignee);
-      } else if (newStatus === "active" && oldStatus === "paused") {
-        await this.enableAutonomous(goal.assignee);
-      } else if (isGoalTerminal(newStatus)) {
-        await this.maybeDisableAutonomous(goal.assignee);
-      }
-    }
-    return goal;
-  }
-  async update(id, fields) {
-    const goal = await this.get(id);
-    const oldAssignee = goal.assignee;
-    if (fields.title !== void 0) {
-      if (!fields.title.trim()) throw new InvalidArgumentsError("Goal title cannot be empty");
-      goal.title = fields.title.trim();
-    }
-    if (fields.description !== void 0) goal.description = fields.description.trim();
-    if (fields.assignee !== void 0) goal.assignee = fields.assignee || void 0;
-    goal.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.goalStore.save(goal);
-    this.eventBus.emit({ type: "goal:updated", goalId: id });
-    const newAssignee = goal.assignee;
-    if (newAssignee !== oldAssignee) {
-      const ops = [];
-      if (newAssignee) ops.push(this.enableAutonomous(newAssignee));
-      if (oldAssignee) ops.push(this.maybeDisableAutonomous(oldAssignee));
-      await Promise.all(ops);
-    }
-    return goal;
-  }
-  async delete(id) {
-    const goal = await this.get(id);
-    const { assignee } = goal;
-    await this.goalStore.delete(id);
-    this.eventBus.emit({ type: "goal:deleted", goalId: id });
-    if (assignee) {
-      await this.maybeDisableAutonomous(assignee);
-    }
-  }
-  /** Enable autonomous mode on an agent. */
-  async enableAutonomous(agentId) {
-    if (!this.agentService) return;
-    try {
-      await this.agentService.setAutonomous(agentId, true);
-    } catch {
-    }
-  }
-  /** Check if an agent has at least one active goal. */
-  async hasActiveGoalsForAgent(agentId) {
-    const activeGoals = await this.goalStore.list({ status: "active" });
-    return activeGoals.some((g) => g.assignee === agentId);
-  }
-  /** Cancel dispatchable (todo/retrying) autonomous tasks assigned to the agent. */
-  async cancelPendingAutonomousTasks(agentId) {
-    if (!this.taskService) return;
-    try {
-      const [todos, retrying] = await Promise.all([
-        this.taskService.list({ status: "todo" }),
-        this.taskService.list({ status: "retrying" })
-      ]);
-      const pending = [...todos, ...retrying].filter(
-        (t) => t.assignee === agentId && t.labels?.includes(AUTONOMOUS_LABEL)
-      );
-      await Promise.all(pending.map((t) => this.taskService.cancel(t.id).catch(() => {
-      })));
-    } catch {
-    }
-  }
-  /** Disable autonomous if agent has no other active goals. */
-  async maybeDisableAutonomous(agentId) {
-    if (!this.agentService) return;
-    try {
-      if (!await this.hasActiveGoalsForAgent(agentId)) {
-        await this.agentService.setAutonomous(agentId, false);
-      }
-    } catch {
-    }
-  }
-};
-
-// src/domain/team.ts
-var DEFAULT_TEAM_CONFIG = {
-  auto_claim: true,
-  message_ttl_ms: 24 * 60 * 60 * 1e3
-};
-
-// src/application/team-service.ts
-var TeamService = class {
-  constructor(teamStore, agentStore, taskStore, eventBus) {
-    this.teamStore = teamStore;
-    this.agentStore = agentStore;
-    this.taskStore = taskStore;
-    this.eventBus = eventBus;
-  }
-  async create(input) {
-    if (!input.name.trim()) throw new InvalidArgumentsError("Team name is required");
-    const lead = await this.agentStore.get(input.lead_agent_id);
-    if (!lead) throw new InvalidArgumentsError(`Lead agent not found: ${input.lead_agent_id}`);
-    const existing = await this.teamStore.getByName(input.name.trim());
-    if (existing) throw new InvalidArgumentsError(`Team "${input.name}" already exists`);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const leadMember = { agent_id: input.lead_agent_id, role: "lead", joined_at: now };
-    const additionalMembers = [];
-    for (const agentId of input.member_agent_ids ?? []) {
-      if (agentId === input.lead_agent_id) continue;
-      const agent = await this.agentStore.get(agentId);
-      if (!agent) throw new InvalidArgumentsError(`Member agent not found: ${agentId}`);
-      additionalMembers.push({ agent_id: agentId, role: "member", joined_at: now });
-    }
-    const team = {
-      id: `team_${nanoid(7)}`,
-      name: input.name.trim(),
-      description: input.description,
-      status: "active",
-      members: [leadMember, ...additionalMembers],
-      task_pool: [],
-      lead_agent_id: input.lead_agent_id,
-      created_at: now,
-      updated_at: now,
-      config: { ...DEFAULT_TEAM_CONFIG, ...input.config ?? {} }
-    };
-    await this.teamStore.save(team);
-    this.eventBus.emit({ type: "team:created", teamId: team.id, name: team.name, leadAgentId: team.lead_agent_id });
-    for (const member of additionalMembers) {
-      this.eventBus.emit({ type: "team:member_joined", teamId: team.id, agentId: member.agent_id });
-    }
-    return team;
-  }
-  async get(id) {
-    const team = await this.teamStore.get(id);
-    if (!team) throw new TeamNotFoundError(id);
-    return team;
-  }
-  async list() {
-    return this.teamStore.list();
-  }
-  async join(teamId, agentId) {
-    const team = await this.get(teamId);
-    if (team.members.some((m) => m.agent_id === agentId)) {
-      throw new InvalidArgumentsError(`Agent ${agentId} is already a member of team ${teamId}`);
-    }
-    const agent = await this.agentStore.get(agentId);
-    if (!agent) throw new InvalidArgumentsError(`Agent not found: ${agentId}`);
-    team.members.push({ agent_id: agentId, role: "member", joined_at: (/* @__PURE__ */ new Date()).toISOString() });
-    team.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.teamStore.save(team);
-    this.eventBus.emit({ type: "team:member_joined", teamId, agentId });
-    return team;
-  }
-  async leave(teamId, agentId) {
-    const team = await this.get(teamId);
-    if (agentId === team.lead_agent_id) {
-      throw new InvalidArgumentsError("Lead cannot leave team. Disband the team or transfer lead first.");
-    }
-    team.members = team.members.filter((m) => m.agent_id !== agentId);
-    team.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.teamStore.save(team);
-    this.eventBus.emit({ type: "team:member_left", teamId, agentId });
-    return team;
-  }
-  async addTask(teamId, taskId) {
-    const team = await this.get(teamId);
-    const task = await this.taskStore.get(taskId);
-    if (!task) throw new InvalidArgumentsError(`Task not found: ${taskId}`);
-    if (!team.task_pool.includes(taskId)) {
-      team.task_pool.push(taskId);
-      team.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      await this.teamStore.save(team);
-      this.eventBus.emit({ type: "team:task_added", teamId, taskId });
-    }
-    return team;
-  }
-  async removeTask(teamId, taskId) {
-    const team = await this.get(teamId);
-    team.task_pool = team.task_pool.filter((id) => id !== taskId);
-    team.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.teamStore.save(team);
-    return team;
-  }
-  async setLead(teamId, agentId) {
-    const team = await this.get(teamId);
-    const member = team.members.find((m) => m.agent_id === agentId);
-    if (!member) throw new InvalidArgumentsError(`Agent ${agentId} is not a member of team ${teamId}`);
-    const currentLead = team.members.find((m) => m.agent_id === team.lead_agent_id);
-    if (currentLead) currentLead.role = "member";
-    member.role = "lead";
-    team.lead_agent_id = agentId;
-    team.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.teamStore.save(team);
-    return team;
-  }
-  async disband(teamId) {
-    const team = await this.get(teamId);
-    team.status = "disbanded";
-    team.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await this.teamStore.save(team);
-    this.eventBus.emit({ type: "team:disbanded", teamId });
-  }
-  /**
-   * Find the team an agent belongs to (if any).
-   */
-  async findTeamForAgent(agentId) {
-    const teams = await this.teamStore.list();
-    return teams.find((t) => t.status === "active" && t.members.some((m) => m.agent_id === agentId)) ?? null;
-  }
-};
-
-// src/container.ts
-async function buildLightContainer(context) {
-  const paths = new Paths(context.projectRoot);
-  await paths.requireInit();
-  const configStore = new ConfigStore(paths);
-  const globalConfigStore = new GlobalConfigStore();
-  const [config, globalConfig] = await Promise.all([
-    configStore.read(),
-    globalConfigStore.read()
-  ]);
-  const taskStore = new TaskStore(paths);
-  const agentStore = new AgentStore(paths);
-  const runStore = new RunStore(paths);
-  const stateStore = new StateStore(paths);
-  const contextStore = new ContextStore(paths);
-  const messageStore = new MessageStore(paths);
-  const goalStore = new GoalStore(paths);
-  const teamStore = new TeamStore(paths);
-  const eventBus = new EventBus();
-  const taskService = new TaskService(taskStore, eventBus, config);
-  const agentService = new AgentService(agentStore, stateStore, eventBus, config);
-  const runService = new RunService(runStore, eventBus);
-  const messageService = new MessageService(messageStore, agentStore, teamStore, eventBus);
-  const goalService = new GoalService(goalStore, eventBus, agentService, taskService);
-  const teamService = new TeamService(teamStore, agentStore, taskStore, eventBus);
-  return {
-    context,
-    paths,
-    config,
-    taskStore,
-    agentStore,
-    runStore,
-    stateStore,
-    configStore,
-    globalConfigStore,
-    globalConfig,
-    contextStore,
-    messageStore,
-    goalStore,
-    teamStore,
-    eventBus,
-    taskService,
-    agentService,
-    runService,
-    messageService,
-    goalService,
-    teamService
-  };
-}
-async function buildFullContainer(context) {
-  const light = await buildLightContainer(context);
-  const [
-    { ProcessManager },
-    { AdapterRegistry },
-    { ClaudeAdapter },
-    { CodexAdapter },
-    { CursorAdapter },
-    { ShellAdapter },
-    { WorkspaceManager },
-    { LiquidTemplateEngine },
-    { Orchestrator },
-    { DoctorService }
-  ] = await Promise.all([
-    import('./process-manager-HUVNAPQV.js'),
-    import('./registry-PQWRVNF2.js'),
-    import('./claude-GH6P2DC5.js'),
-    import('./codex-U7LTJTX6.js'),
-    import('./cursor-3DI5GKRF.js'),
-    import('./shell-5ZNXFGXV.js'),
-    import('./workspace-manager-47KI7B27.js'),
-    import('./template-engine-3CDRZNMJ.js'),
-    import('./orchestrator-VGYKSOZJ.js'),
-    import('./doctor-service-A34DHPKI.js')
-  ]);
-  const processManager = new ProcessManager();
-  const templateEngine = new LiquidTemplateEngine();
-  const workspaceManager = new WorkspaceManager(
-    context.projectRoot,
-    light.paths.root,
-    processManager
-  );
-  const adapterRegistry = new AdapterRegistry();
-  adapterRegistry.register(new ClaudeAdapter(processManager));
-  adapterRegistry.register(new CodexAdapter(processManager));
-  adapterRegistry.register(new CursorAdapter(processManager));
-  adapterRegistry.register(new ShellAdapter(processManager));
-  const doctorService = new DoctorService(adapterRegistry, processManager);
-  const orchestrator = new Orchestrator({
-    taskStore: light.taskStore,
-    agentStore: light.agentStore,
-    runStore: light.runStore,
-    stateStore: light.stateStore,
-    adapterRegistry,
-    workspaceManager,
-    templateEngine,
-    processManager,
-    eventBus: light.eventBus,
-    taskService: light.taskService,
-    agentService: light.agentService,
-    runService: light.runService,
-    contextStore: light.contextStore,
-    messageService: light.messageService,
-    goalStore: light.goalStore,
-    config: light.config,
-    projectRoot: context.projectRoot,
-    lockPath: light.paths.lockPath
-  });
-  return {
-    ...light,
-    processManager,
-    adapterRegistry,
-    workspaceManager,
-    templateEngine,
-    doctorService,
-    orchestrator
-  };
-}
-async function buildContainer(context) {
-  return buildFullContainer(context);
-}
-
-export { buildContainer, buildFullContainer, buildLightContainer };