ccjk 12.0.7 → 12.0.8

package/dist/chunks/convoy-manager.mjs

@@ -1,880 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { x as K } from './main.mjs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-
-class GitBackedStateManager extends EventEmitter {
-  config;
-  worktrees = /* @__PURE__ */ new Map();
-  initialized = false;
-  pendingCommits = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    super();
-    this.config = {
-      workspaceRoot: config.workspaceRoot ?? join(homedir(), ".ccjk", "workspace"),
-      useWorktrees: config.useWorktrees ?? true,
-      autoCommit: config.autoCommit ?? true,
-      compressionLevel: config.compressionLevel ?? 6,
-      verbose: config.verbose ?? false,
-      commitBatchInterval: config.commitBatchInterval ?? 1e3
-    };
-  }
-  /**
-   * Initialize the workspace with Git
-   */
-  async initialize() {
-    if (this.initialized)
-      return;
-    const { workspaceRoot } = this.config;
-    try {
-      if (!existsSync(workspaceRoot)) {
-        mkdirSync(workspaceRoot, { recursive: true });
-        this.log(`Created workspace: ${workspaceRoot}`);
-      }
-      const gitDir = join(workspaceRoot, ".git");
-      if (!existsSync(gitDir)) {
-        await this.exec("git", ["init"], workspaceRoot);
-        this.log("Initialized Git repository");
-        const gitignore = `
-# Sensitive data
-*.env
-*.key
-*.pem
-credentials.json
-
-# Temporary files
-*.tmp
-*.log
-*.swp
-
-# OS files
-.DS_Store
-Thumbs.db
-`;
-        writeFileSync(join(workspaceRoot, ".gitignore"), gitignore.trim());
-        await this.exec("git", ["add", ".gitignore"], workspaceRoot);
-        await this.exec("git", ["commit", "-m", "Initial commit"], workspaceRoot);
-        this.log("Created initial commit");
-      }
-      const agentsDir = join(workspaceRoot, "agents");
-      if (!existsSync(agentsDir)) {
-        mkdirSync(agentsDir, { recursive: true });
-      }
-      await this.loadExistingWorktrees();
-      this.initialized = true;
-      this.emit("initialized");
-      this.log("GitBackedStateManager initialized");
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      throw err;
-    }
-  }
-  /**
-   * Create isolated worktree for agent
-   */
-  async createAgentWorktree(agentId) {
-    await this.ensureInitialized();
-    const { workspaceRoot, useWorktrees } = this.config;
-    if (this.worktrees.has(agentId)) {
-      return this.worktrees.get(agentId);
-    }
-    const agentPath = join(workspaceRoot, "agents", agentId);
-    if (useWorktrees) {
-      const branchName = `agent/${agentId}`;
-      try {
-        await this.exec("git", ["checkout", "--orphan", branchName], workspaceRoot);
-        await this.exec("git", ["reset", "--hard"], workspaceRoot);
-        await this.exec("git", ["checkout", "main"], workspaceRoot).catch(() => {
-          return this.exec("git", ["checkout", "master"], workspaceRoot);
-        });
-        if (!existsSync(agentPath)) {
-          await this.exec("git", ["worktree", "add", agentPath, branchName], workspaceRoot);
-        }
-      } catch {
-        if (!existsSync(agentPath)) {
-          mkdirSync(agentPath, { recursive: true });
-        }
-      }
-    } else {
-      if (!existsSync(agentPath)) {
-        mkdirSync(agentPath, { recursive: true });
-      }
-    }
-    const stateFile = join(agentPath, "state.json");
-    const mailboxFile = join(agentPath, "mailbox.json");
-    if (!existsSync(stateFile)) {
-      writeFileSync(stateFile, JSON.stringify({ agentId, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
-    }
-    if (!existsSync(mailboxFile)) {
-      writeFileSync(mailboxFile, JSON.stringify({ inbox: [], outbox: [], archive: [] }, null, 2));
-    }
-    this.worktrees.set(agentId, agentPath);
-    this.emit("worktree:created", agentId, agentPath);
-    this.log(`Created worktree for agent: ${agentId}`);
-    return agentPath;
-  }
-  /**
-   * Save agent state to Git
-   */
-  async saveState(agentId, state) {
-    await this.ensureInitialized();
-    const agentPath = await this.getOrCreateAgentPath(agentId);
-    const stateFile = join(agentPath, "state.json");
-    let existingState = {};
-    if (existsSync(stateFile)) {
-      try {
-        existingState = JSON.parse(readFileSync(stateFile, "utf-8"));
-      } catch {
-      }
-    }
-    const newState = {
-      ...existingState,
-      ...state,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeFileSync(stateFile, JSON.stringify(newState, null, 2));
-    let commitId = "";
-    if (this.config.autoCommit) {
-      commitId = await this.batchCommit(agentId, `Update state: ${agentId}`);
-    }
-    this.emit("state:saved", agentId, commitId);
-    this.log(`Saved state for agent: ${agentId}`);
-    return commitId;
-  }
-  /**
-   * Load agent state from Git
-   */
-  async loadState(agentId) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return null;
-    }
-    const stateFile = join(agentPath, "state.json");
-    if (!existsSync(stateFile)) {
-      return null;
-    }
-    try {
-      const state = JSON.parse(readFileSync(stateFile, "utf-8"));
-      this.emit("state:loaded", agentId);
-      this.log(`Loaded state for agent: ${agentId}`);
-      return state;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Rollback to previous state
-   */
-  async rollback(agentId, commitId) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      throw new Error(`Agent not found: ${agentId}`);
-    }
-    try {
-      await this.exec("git", ["reset", "--hard", commitId], agentPath);
-      this.emit("state:rolled-back", agentId, commitId);
-      this.log(`Rolled back agent ${agentId} to commit ${commitId}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      throw err;
-    }
-  }
-  /**
-   * Get state history for agent
-   */
-  async getHistory(agentId, limit = 10) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return [];
-    }
-    try {
-      const result = await this.exec(
-        "git",
-        ["log", `--max-count=${limit}`, "--format=%H|%s|%ct", "--", "state.json"],
-        agentPath
-      );
-      const snapshots = [];
-      for (const line of result.stdout.split("\n").filter(Boolean)) {
-        const [commitId, message, timestamp] = line.split("|");
-        const stateResult = await this.exec(
-          "git",
-          ["show", `${commitId}:state.json`],
-          agentPath
-        ).catch(() => ({ stdout: "{}" }));
-        let state;
-        try {
-          state = JSON.parse(stateResult.stdout);
-        } catch {
-          state = {};
-        }
-        snapshots.push({
-          id: nanoid(),
-          agentId,
-          commitId,
-          timestamp: Number.parseInt(timestamp, 10) * 1e3,
-          message,
-          state
-        });
-      }
-      return snapshots;
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * Cleanup agent worktree
-   */
-  async cleanup(agentId) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return;
-    }
-    try {
-      if (this.config.useWorktrees) {
-        await this.exec("git", ["worktree", "remove", agentPath, "--force"], this.config.workspaceRoot);
-      }
-      this.worktrees.delete(agentId);
-      this.emit("worktree:removed", agentId);
-      this.log(`Cleaned up worktree for agent: ${agentId}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit("error", err);
-      throw err;
-    }
-  }
-  /**
-   * Get all agent IDs
-   */
-  getAgentIds() {
-    return Array.from(this.worktrees.keys());
-  }
-  /**
-   * Check if agent exists
-   */
-  hasAgent(agentId) {
-    return this.worktrees.has(agentId);
-  }
-  /**
-   * Get workspace root path
-   */
-  getWorkspaceRoot() {
-    return this.config.workspaceRoot;
-  }
-  /**
-   * Get agent path
-   */
-  getAgentPath(agentId) {
-    return this.worktrees.get(agentId);
-  }
-  /**
-   * Get state history for agent
-   */
-  async getStateHistory(agentId, limit = 20) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return { agentId, commits: [], totalCommits: 0 };
-    }
-    try {
-      const result = await this.exec(
-        "git",
-        ["log", `--max-count=${limit}`, "--format=%H|%s|%ct", "--", "state.json"],
-        agentPath
-      );
-      const commits = result.stdout.split("\n").filter(Boolean).map((line) => {
-        const [id, message, timestamp] = line.split("|");
-        return {
-          id,
-          message,
-          timestamp: Number.parseInt(timestamp, 10) * 1e3
-        };
-      });
-      const countResult = await this.exec(
-        "git",
-        ["rev-list", "--count", "HEAD", "--", "state.json"],
-        agentPath
-      ).catch(() => ({ stdout: "0" }));
-      return {
-        agentId,
-        commits,
-        totalCommits: Number.parseInt(countResult.stdout.trim(), 10) || commits.length
-      };
-    } catch {
-      return { agentId, commits: [], totalCommits: 0 };
-    }
-  }
-  /**
-   * Create a named snapshot of current state
-   */
-  async createSnapshot(agentId, description) {
-    await this.ensureInitialized();
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      throw new Error(`Agent not found: ${agentId}`);
-    }
-    const commitId = await this.commit(agentId, `Snapshot: ${description}`);
-    if (!commitId) {
-      const result = await this.exec("git", ["rev-parse", "HEAD"], agentPath);
-      const currentCommitId = result.stdout.trim();
-      const state2 = await this.loadState(agentId);
-      return {
-        id: nanoid(),
-        agentId,
-        commitId: currentCommitId,
-        timestamp: Date.now(),
-        message: description,
-        state: state2 ?? {}
-      };
-    }
-    const state = await this.loadState(agentId);
-    return {
-      id: nanoid(),
-      agentId,
-      commitId,
-      timestamp: Date.now(),
-      message: description,
-      state: state ?? {}
-    };
-  }
-  /**
-   * Restore state from a snapshot
-   */
-  async restoreSnapshot(agentId, snapshotId) {
-    await this.rollback(agentId, snapshotId);
-  }
-  /**
-   * Sync with remote (if configured)
-   */
-  async syncWithRemote() {
-    await this.ensureInitialized();
-    try {
-      const remoteResult = await this.exec("git", ["remote"], this.config.workspaceRoot);
-      if (!remoteResult.stdout.trim()) {
-        this.log("No remote configured, skipping sync");
-        return;
-      }
-      await this.exec("git", ["pull", "--rebase"], this.config.workspaceRoot);
-      await this.exec("git", ["push"], this.config.workspaceRoot);
-      this.log("Synced with remote");
-    } catch (error) {
-      this.log(`Sync failed: ${error}`);
-    }
-  }
-  // ========================================================================
-  // Private Methods
-  // ========================================================================
-  async ensureInitialized() {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-  }
-  async getOrCreateAgentPath(agentId) {
-    if (!this.worktrees.has(agentId)) {
-      await this.createAgentWorktree(agentId);
-    }
-    return this.worktrees.get(agentId);
-  }
-  async loadExistingWorktrees() {
-    const agentsDir = join(this.config.workspaceRoot, "agents");
-    if (!existsSync(agentsDir)) {
-      return;
-    }
-    try {
-      const { readdirSync, statSync } = await import('node:fs');
-      const entries = readdirSync(agentsDir);
-      for (const entry of entries) {
-        const entryPath = join(agentsDir, entry);
-        if (statSync(entryPath).isDirectory()) {
-          this.worktrees.set(entry, entryPath);
-          this.log(`Loaded existing worktree: ${entry}`);
-        }
-      }
-    } catch {
-    }
-  }
-  async batchCommit(agentId, message) {
-    const existing = this.pendingCommits.get(agentId);
-    if (existing) {
-      clearTimeout(existing);
-    }
-    return new Promise((resolve) => {
-      const timeout = setTimeout(async () => {
-        this.pendingCommits.delete(agentId);
-        const commitId = await this.commit(agentId, message);
-        resolve(commitId);
-      }, this.config.commitBatchInterval);
-      this.pendingCommits.set(agentId, timeout);
-    });
-  }
-  async commit(agentId, message) {
-    const agentPath = this.worktrees.get(agentId);
-    if (!agentPath) {
-      return "";
-    }
-    try {
-      await this.exec("git", ["add", "-A"], agentPath);
-      const statusResult = await this.exec("git", ["status", "--porcelain"], agentPath);
-      if (!statusResult.stdout.trim()) {
-        return "";
-      }
-      await this.exec("git", ["commit", "-m", message], agentPath);
-      const result = await this.exec("git", ["rev-parse", "HEAD"], agentPath);
-      return result.stdout.trim();
-    } catch {
-      return "";
-    }
-  }
-  async exec(cmd, args, cwd) {
-    const result = await K(cmd, args, { nodeOptions: { cwd } });
-    return {
-      stdout: result.stdout,
-      stderr: result.stderr
-    };
-  }
-  log(message) {
-    if (this.config.verbose) {
-      console.log(`[GitBackedState] ${message}`);
-    }
-  }
-}
-let globalStateManager = null;
-function getGlobalStateManager(config) {
-  if (!globalStateManager) {
-    globalStateManager = new GitBackedStateManager(config);
-  }
-  return globalStateManager;
-}
-
-const gitBackedState = {
-  __proto__: null,
-  GitBackedStateManager: GitBackedStateManager,
-  getGlobalStateManager: getGlobalStateManager
-};
-
-class ConvoyManager extends EventEmitter {
-  stateManager;
-  convoys = /* @__PURE__ */ new Map();
-  initialized = false;
-  constructor(stateManager) {
-    super();
-    this.stateManager = stateManager ?? getGlobalStateManager();
-  }
-  /**
-   * Initialize convoy manager
-   */
-  async initialize() {
-    if (this.initialized)
-      return;
-    await this.stateManager.initialize();
-    await this.loadConvoys();
-    this.initialized = true;
-  }
-  /**
-   * Create new convoy
-   */
-  async create(name, options = {}) {
-    await this.ensureInitialized();
-    const convoy = {
-      id: `cv-${nanoid(6)}`,
-      name,
-      description: options.description ?? "",
-      tasks: [],
-      status: "pending",
-      progress: 0,
-      totalTasks: 0,
-      completedTasks: 0,
-      failedTasks: 0,
-      cancelledTasks: 0,
-      skippedTasks: 0,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      createdBy: options.createdBy ?? "system",
-      notifications: {
-        onComplete: options.notifyOnComplete ?? false,
-        onFailure: options.notifyOnFailure ?? true,
-        onProgress: options.notifyOnProgress ?? false,
-        notifyHuman: options.notifyHuman ?? false
-      },
-      metadata: options.metadata,
-      tags: options.tags ?? []
-    };
-    this.convoys.set(convoy.id, convoy);
-    await this.persistConvoy(convoy);
-    this.emit("convoy:created", convoy);
-    return convoy;
-  }
-  /**
-   * Add task to convoy
-   */
-  async addTask(convoyId, title, options = {}) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = {
-      id: `task-${nanoid(6)}`,
-      title,
-      description: options.description ?? "",
-      status: "pending",
-      assignedTo: options.assignedTo,
-      dependsOn: options.dependsOn ?? [],
-      metadata: options.metadata
-    };
-    convoy.tasks.push(task);
-    convoy.totalTasks = convoy.tasks.length;
-    this.updateProgress(convoy);
-    await this.persistConvoy(convoy);
-    return task;
-  }
-  /**
-   * Add multiple tasks to convoy
-   */
-  async addTasks(convoyId, tasks) {
-    const addedTasks = [];
-    for (const { title, options } of tasks) {
-      const task = await this.addTask(convoyId, title, options);
-      addedTasks.push(task);
-    }
-    return addedTasks;
-  }
-  /**
-   * Start convoy execution
-   */
-  async start(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    if (convoy.status !== "pending" && convoy.status !== "paused") {
-      throw new Error(`Cannot start convoy in status: ${convoy.status}`);
-    }
-    convoy.status = "in_progress";
-    convoy.startedAt = convoy.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    await this.persistConvoy(convoy);
-    this.emit("convoy:started", convoy);
-  }
-  /**
-   * Start a task
-   */
-  async startTask(convoyId, taskId, assignedTo) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
-    }
-    const unmetDeps = this.getUnmetDependencies(convoy, task);
-    if (unmetDeps.length > 0) {
-      throw new Error(`Task has unmet dependencies: ${unmetDeps.join(", ")}`);
-    }
-    task.status = "in_progress";
-    task.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    if (assignedTo) {
-      task.assignedTo = assignedTo;
-    }
-    if (convoy.status === "pending") {
-      convoy.status = "in_progress";
-      convoy.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    await this.persistConvoy(convoy);
-    this.emit("task:started", convoy, task);
-  }
-  /**
-   * Complete a task
-   */
-  async completeTask(convoyId, taskId, result) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
-    }
-    task.status = "completed";
-    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    task.result = result;
-    convoy.completedTasks++;
-    this.updateProgress(convoy);
-    this.checkConvoyCompletion(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("task:completed", convoy, task);
-    if (convoy.notifications.onProgress) {
-      this.emit("convoy:progress", convoy, convoy.progress);
-    }
-  }
-  /**
-   * Fail a task
-   */
-  async failTask(convoyId, taskId, error) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
-    }
-    task.status = "failed";
-    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    task.error = error;
-    convoy.failedTasks++;
-    this.updateProgress(convoy);
-    await this.skipDependentTasks(convoy, taskId);
-    this.checkConvoyCompletion(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("task:failed", convoy, task);
-    if (convoy.notifications.onFailure) {
-      this.emit("convoy:failed", convoy);
-    }
-  }
-  /**
-   * Cancel a task
-   */
-  async cancelTask(convoyId, taskId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    const task = convoy.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId}`);
-    }
-    task.status = "cancelled";
-    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    convoy.cancelledTasks++;
-    this.updateProgress(convoy);
-    await this.skipDependentTasks(convoy, taskId);
-    this.checkConvoyCompletion(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("task:cancelled", convoy, task);
-  }
-  /**
-   * Pause convoy
-   */
-  async pause(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    if (convoy.status !== "in_progress") {
-      throw new Error(`Cannot pause convoy in status: ${convoy.status}`);
-    }
-    convoy.status = "paused";
-    await this.persistConvoy(convoy);
-    this.emit("convoy:paused", convoy);
-  }
-  /**
-   * Resume convoy
-   */
-  async resume(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    if (convoy.status !== "paused") {
-      throw new Error(`Cannot resume convoy in status: ${convoy.status}`);
-    }
-    convoy.status = "in_progress";
-    await this.persistConvoy(convoy);
-    this.emit("convoy:resumed", convoy);
-  }
-  /**
-   * Cancel convoy
-   */
-  async cancel(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy) {
-      throw new Error(`Convoy not found: ${convoyId}`);
-    }
-    convoy.status = "cancelled";
-    convoy.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    for (const task of convoy.tasks) {
-      if (task.status === "pending" || task.status === "in_progress") {
-        task.status = "cancelled";
-        task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        convoy.cancelledTasks++;
-      }
-    }
-    this.updateProgress(convoy);
-    await this.persistConvoy(convoy);
-    this.emit("convoy:cancelled", convoy);
-  }
-  /**
-   * Get convoy by ID
-   */
-  get(convoyId) {
-    return this.convoys.get(convoyId);
-  }
-  /**
-   * List all convoys
-   */
-  list(filter) {
-    let convoys = Array.from(this.convoys.values());
-    if (filter) {
-      if (filter.status) {
-        convoys = convoys.filter((c) => c.status === filter.status);
-      }
-      if (filter.createdBy) {
-        convoys = convoys.filter((c) => c.createdBy === filter.createdBy);
-      }
-      if (filter.tags && filter.tags.length > 0) {
-        convoys = convoys.filter(
-          (c) => filter.tags.some((tag) => c.tags.includes(tag))
-        );
-      }
-    }
-    return convoys.sort(
-      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
-    );
-  }
-  /**
-   * Get active convoys
-   */
-  getActive() {
-    return this.list({ status: "in_progress" });
-  }
-  /**
-   * Get next available tasks (no unmet dependencies)
-   */
-  getNextTasks(convoyId) {
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy)
-      return [];
-    return convoy.tasks.filter((task) => {
-      if (task.status !== "pending")
-        return false;
-      return this.getUnmetDependencies(convoy, task).length === 0;
-    });
-  }
-  /**
-   * Get convoy summary
-   */
-  getSummary(convoyId) {
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy)
-      return "Convoy not found";
-    const lines = [
-      `Convoy: ${convoy.name} (${convoy.id})`,
-      `Status: ${convoy.status}`,
-      `Progress: ${convoy.progress}%`,
-      `Tasks: ${convoy.completedTasks}/${convoy.totalTasks} completed`
-    ];
-    if (convoy.failedTasks > 0) {
-      lines.push(`Failed: ${convoy.failedTasks}`);
-    }
-    if (convoy.cancelledTasks > 0) {
-      lines.push(`Cancelled: ${convoy.cancelledTasks}`);
-    }
-    if (convoy.skippedTasks > 0) {
-      lines.push(`Skipped: ${convoy.skippedTasks}`);
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Delete convoy
-   */
-  async delete(convoyId) {
-    await this.ensureInitialized();
-    const convoy = this.convoys.get(convoyId);
-    if (!convoy)
-      return false;
-    this.convoys.delete(convoyId);
-    return true;
-  }
-  // ========================================================================
-  // Private Methods
-  // ========================================================================
-  async ensureInitialized() {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-  }
-  updateProgress(convoy) {
-    const processed = convoy.completedTasks + convoy.failedTasks + convoy.cancelledTasks + convoy.skippedTasks;
-    convoy.progress = convoy.totalTasks > 0 ? Math.round(processed / convoy.totalTasks * 100) : 0;
-  }
-  checkConvoyCompletion(convoy) {
-    const processed = convoy.completedTasks + convoy.failedTasks + convoy.cancelledTasks + convoy.skippedTasks;
-    if (processed === convoy.totalTasks) {
-      convoy.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      if (convoy.failedTasks === 0 && convoy.cancelledTasks === 0) {
-        convoy.status = "completed";
-        if (convoy.notifications.onComplete) {
-          this.emit("convoy:completed", convoy);
-        }
-      } else {
-        convoy.status = "failed";
-        if (convoy.notifications.onFailure) {
-          this.emit("convoy:failed", convoy);
-        }
-      }
-    }
-  }
-  getUnmetDependencies(convoy, task) {
-    return task.dependsOn.filter((depId) => {
-      const depTask = convoy.tasks.find((t) => t.id === depId);
-      return !depTask || depTask.status !== "completed";
-    });
-  }
-  async skipDependentTasks(convoy, failedTaskId) {
-    for (const task of convoy.tasks) {
-      if (task.status === "pending" && task.dependsOn.includes(failedTaskId)) {
-        task.status = "skipped";
-        task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        task.error = `Skipped due to failed dependency: ${failedTaskId}`;
-        convoy.skippedTasks++;
-        this.emit("task:skipped", convoy, task);
-        await this.skipDependentTasks(convoy, task.id);
-      }
-    }
-  }
-  async loadConvoys() {
-    for (const agentId of this.stateManager.getAgentIds()) {
-      if (agentId.startsWith("convoy-")) {
-        const state = await this.stateManager.loadState(agentId);
-        if (state) {
-          const convoy = state;
-          this.convoys.set(convoy.id, convoy);
-        }
-      }
-    }
-  }
-  async persistConvoy(convoy) {
-    await this.stateManager.createAgentWorktree(`convoy-${convoy.id}`);
-    await this.stateManager.saveState(`convoy-${convoy.id}`, convoy);
-  }
-}
-let globalConvoyManager = null;
-function getGlobalConvoyManager() {
-  if (!globalConvoyManager) {
-    globalConvoyManager = new ConvoyManager();
-  }
-  return globalConvoyManager;
-}
-
-const convoyManager = {
-  __proto__: null,
-  ConvoyManager: ConvoyManager,
-  getGlobalConvoyManager: getGlobalConvoyManager
-};
-
-export { getGlobalStateManager as a, gitBackedState as b, convoyManager as c, getGlobalConvoyManager as g };