archondev 2.2.0 → 2.4.0

package/dist/{chunk-HGO4UUAC.js → chunk-6TCM6JYX.js}

@@ -4815,7 +4815,7 @@ function createPrompt() {
 }
 async function execute(atomId, options) {
   if (options.parallel && options.parallel.length > 0) {
-    const { parallelExecute } = await import("./parallel-IC6FLPSK.js");
+    const { parallelExecute } = await import("./parallel-34TSORWU.js");
     const allAtomIds = [atomId, ...options.parallel];
     await parallelExecute(allAtomIds);
     return;

package/dist/chunk-Y5LQX7LK.js

@@ -0,0 +1,673 @@
+import {
+  listLocalAtoms,
+  loadAtom
+} from "./chunk-5HVYNCLT.js";
+
+// src/cli/parallel.ts
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/core/parallel/worktree.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+var WorktreeManager = class {
+  cwd;
+  worktreesDir;
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.worktreesDir = join(cwd, ".archon", "worktrees");
+  }
+  async createWorktree(atomId) {
+    const branchName = `archon/${atomId}`;
+    const worktreePath = join(this.worktreesDir, atomId);
+    if (!existsSync(this.worktreesDir)) {
+      mkdirSync(this.worktreesDir, { recursive: true });
+    }
+    execSync(`git worktree add -b ${branchName} "${worktreePath}"`, { cwd: this.cwd });
+    return worktreePath;
+  }
+  async removeWorktree(atomId) {
+    const worktreePath = join(this.worktreesDir, atomId);
+    execSync(`git worktree remove "${worktreePath}"`, { cwd: this.cwd });
+    execSync(`git branch -D archon/${atomId}`, { cwd: this.cwd });
+  }
+  async listWorktrees() {
+    const output = execSync("git worktree list --porcelain", { cwd: this.cwd, encoding: "utf-8" });
+    const worktrees = [];
+    const blocks = output.split("\n\n").filter(Boolean);
+    for (const block of blocks) {
+      const lines = block.split("\n");
+      let path = "";
+      let branch = "";
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          path = line.substring(9);
+        } else if (line.startsWith("branch ")) {
+          branch = line.substring(7);
+        }
+      }
+      if (path.includes(".archon/worktrees/") && branch.startsWith("refs/heads/archon/")) {
+        const atomId = branch.replace("refs/heads/archon/", "");
+        worktrees.push({
+          atomId,
+          path,
+          branch: `archon/${atomId}`,
+          status: "pending"
+        });
+      }
+    }
+    return worktrees;
+  }
+  async mergeWorktree(atomId) {
+    const branchName = `archon/${atomId}`;
+    execSync(`git merge ${branchName}`, { cwd: this.cwd });
+  }
+  getWorktreePath(atomId) {
+    return join(this.worktreesDir, atomId);
+  }
+  worktreeExists(atomId) {
+    return existsSync(join(this.worktreesDir, atomId));
+  }
+};
+
+// src/core/parallel/scheduler.ts
+var FILE_PATTERNS = {
+  setup: ["package.json", "tsconfig.json", ".eslintrc*", "README.md"],
+  database: ["prisma/*", "src/db/*", "supabase/*", "drizzle/*"],
+  auth: ["src/auth/*", "src/lib/auth*", "src/middleware/*"],
+  api: ["src/api/*", "src/routes/*", "src/app/api/*", "pages/api/*"],
+  ui: ["src/components/*", "src/app/*", "src/pages/*", "src/views/*"],
+  testing: ["src/**/*.test.*", "src/**/*.spec.*", "__tests__/*"]
+};
+var KEYWORD_PATTERNS = {
+  user: ["src/db/users*", "src/api/users*", "src/components/user*"],
+  payment: ["src/lib/stripe*", "src/api/payments*", "src/api/checkout*"],
+  dashboard: ["src/app/dashboard/*", "src/components/dashboard*"],
+  admin: ["src/app/admin/*", "src/api/admin/*"]
+};
+function predictFilesTouched(atom) {
+  const files = [];
+  const titleLower = atom.title.toLowerCase();
+  const idLower = atom.id.toLowerCase();
+  for (const [pattern, paths] of Object.entries(FILE_PATTERNS)) {
+    if (idLower.includes(pattern) || titleLower.includes(pattern)) {
+      files.push(...paths);
+    }
+  }
+  for (const [keyword, paths] of Object.entries(KEYWORD_PATTERNS)) {
+    if (titleLower.includes(keyword)) {
+      files.push(...paths);
+    }
+  }
+  if (files.length === 0) {
+    files.push("src/api/*", "src/components/*");
+  }
+  return [...new Set(files)];
+}
+function patternsOverlap(patternA, patternB) {
+  if (patternA === patternB) {
+    return true;
+  }
+  const cleanA = patternA.replace(/\*/g, "");
+  const cleanB = patternB.replace(/\*/g, "");
+  if (!patternA.includes("*") && !patternB.includes("*")) {
+    return patternA === patternB;
+  }
+  if (patternA.includes("*") && !patternB.includes("*")) {
+    const dirA2 = patternA.replace(/\/\*.*$/, "");
+    return patternB.startsWith(dirA2 + "/");
+  }
+  if (patternB.includes("*") && !patternA.includes("*")) {
+    const dirB2 = patternB.replace(/\/\*.*$/, "");
+    return patternA.startsWith(dirB2 + "/");
+  }
+  const dirA = patternA.replace(/\/\*.*$/, "");
+  const dirB = patternB.replace(/\/\*.*$/, "");
+  if (dirA === dirB) {
+    return true;
+  }
+  if (dirA.startsWith(dirB + "/") || dirB.startsWith(dirA + "/")) {
+    return true;
+  }
+  return false;
+}
+function buildDependencyGraph(atoms, options = {}) {
+  const graph = { atoms, edges: [] };
+  const predictFn = options.predictFilesTouched ?? predictFilesTouched;
+  for (const atom of atoms) {
+    if (atom.dependencies) {
+      for (const depId of atom.dependencies) {
+        if (atoms.some((a) => a.id === depId)) {
+          graph.edges.push({
+            from: depId,
+            to: atom.id,
+            type: "explicit" /* EXPLICIT */,
+            reason: "Explicit dependency"
+          });
+        }
+      }
+    }
+  }
+  const atomFiles = /* @__PURE__ */ new Map();
+  for (const atom of atoms) {
+    const files = atom.filesTouched ?? predictFn(atom);
+    atomFiles.set(atom.id, files);
+  }
+  for (let i = 0; i < atoms.length; i++) {
+    for (let j = i + 1; j < atoms.length; j++) {
+      const atomA = atoms[i];
+      const atomB = atoms[j];
+      if (!atomA || !atomB) continue;
+      const filesA = atomFiles.get(atomA.id) ?? [];
+      const filesB = atomFiles.get(atomB.id) ?? [];
+      const conflicts = [];
+      for (const fileA of filesA) {
+        for (const fileB of filesB) {
+          if (patternsOverlap(fileA, fileB)) {
+            conflicts.push(`${fileA} <-> ${fileB}`);
+          }
+        }
+      }
+      if (conflicts.length > 0) {
+        const hasExplicitDep = graph.edges.some(
+          (e) => e.from === atomA.id && e.to === atomB.id || e.from === atomB.id && e.to === atomA.id
+        );
+        if (!hasExplicitDep) {
+          graph.edges.push({
+            from: atomA.id,
+            to: atomB.id,
+            type: "file_conflict" /* FILE_CONFLICT */,
+            reason: `File conflicts: ${conflicts.slice(0, 3).join(", ")}${conflicts.length > 3 ? "..." : ""}`
+          });
+        }
+      }
+    }
+  }
+  return graph;
+}
+function topologicalSort(graph) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const atom of graph.atoms) {
+    inDegree.set(atom.id, 0);
+    adjacency.set(atom.id, []);
+  }
+  for (const edge of graph.edges) {
+    const adj = adjacency.get(edge.from);
+    if (adj) {
+      adj.push(edge.to);
+    }
+    inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(id);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    if (!nodeId) continue;
+    const node = graph.atoms.find((a) => a.id === nodeId);
+    if (node) {
+      sorted.push(node);
+    }
+    const neighbors = adjacency.get(nodeId) ?? [];
+    for (const neighbor of neighbors) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+  if (sorted.length !== graph.atoms.length) {
+    const remaining = graph.atoms.filter((a) => !sorted.find((s) => s.id === a.id));
+    console.warn(`Cycle detected involving: ${remaining.map((a) => a.id).join(", ")}`);
+    sorted.push(...remaining);
+  }
+  return sorted;
+}
+function findCriticalPath(graph) {
+  const distances = /* @__PURE__ */ new Map();
+  const predecessors = /* @__PURE__ */ new Map();
+  for (const atom of graph.atoms) {
+    distances.set(atom.id, 0);
+    predecessors.set(atom.id, null);
+  }
+  const sorted = topologicalSort(graph);
+  for (const atom of sorted) {
+    const outEdges = graph.edges.filter((e) => e.from === atom.id);
+    const currentDist = distances.get(atom.id) ?? 0;
+    for (const edge of outEdges) {
+      const targetDist = distances.get(edge.to) ?? 0;
+      if (currentDist + 1 > targetDist) {
+        distances.set(edge.to, currentDist + 1);
+        predecessors.set(edge.to, atom.id);
+      }
+    }
+  }
+  let maxDist = 0;
+  let maxNode = "";
+  for (const [id, dist] of distances) {
+    if (dist > maxDist) {
+      maxDist = dist;
+      maxNode = id;
+    }
+  }
+  const path = [];
+  let current = maxNode;
+  while (current) {
+    path.unshift(current);
+    current = predecessors.get(current) ?? null;
+  }
+  return path;
+}
+function scheduleExecution(graph, options = {}) {
+  const maxParallelism = options.maxParallelism ?? Infinity;
+  const waves = [];
+  const completed = /* @__PURE__ */ new Set();
+  const sorted = topologicalSort(graph);
+  let waveNumber = 1;
+  while (completed.size < graph.atoms.length) {
+    const waveAtoms = [];
+    for (const atom of sorted) {
+      if (completed.has(atom.id)) continue;
+      if (waveAtoms.length >= maxParallelism) break;
+      const deps = graph.edges.filter((e) => e.to === atom.id).map((e) => e.from);
+      const ready = deps.every((d) => completed.has(d));
+      if (ready) {
+        waveAtoms.push(atom);
+      }
+    }
+    if (waveAtoms.length === 0) {
+      const remaining = sorted.filter((a) => !completed.has(a.id));
+      if (remaining.length > 0 && remaining[0]) {
+        waveAtoms.push(remaining[0]);
+      } else {
+        break;
+      }
+    }
+    for (const atom of waveAtoms) {
+      completed.add(atom.id);
+    }
+    waves.push({
+      waveNumber,
+      atoms: waveAtoms
+    });
+    waveNumber++;
+  }
+  const parallelism = waves.map((w) => w.atoms.length);
+  const criticalPath = findCriticalPath(graph);
+  const serialTime = graph.atoms.length;
+  const parallelTime = waves.length;
+  const estimatedSpeedup = serialTime / parallelTime;
+  return {
+    waves,
+    totalAtoms: graph.atoms.length,
+    parallelism,
+    criticalPath,
+    estimatedSpeedup: Math.round(estimatedSpeedup * 100) / 100
+  };
+}
+function formatExecutionPlan(plan) {
+  const lines = [];
+  lines.push(`Execution Plan: ${plan.totalAtoms} atoms in ${plan.waves.length} waves`);
+  lines.push(`Estimated speedup: ${plan.estimatedSpeedup}\xD7 (vs serial execution)`);
+  lines.push("");
+  for (const wave of plan.waves) {
+    const atomLabels = wave.atoms.map((a) => `[${a.id}]`).join(" ");
+    const prefix = `Wave ${wave.waveNumber}:`.padEnd(10);
+    lines.push(`${prefix}${atomLabels}`);
+  }
+  if (plan.criticalPath.length > 1) {
+    lines.push("");
+    lines.push(`Critical path: ${plan.criticalPath.join(" \u2192 ")}`);
+  }
+  return lines.join("\n");
+}
+function formatAsMermaid(graph) {
+  const lines = ["graph TD"];
+  for (const atom of graph.atoms) {
+    const label = atom.title.length > 30 ? atom.title.substring(0, 27) + "..." : atom.title;
+    lines.push(`  ${atom.id}["${label}"]`);
+  }
+  for (const edge of graph.edges) {
+    const style = edge.type === "explicit" /* EXPLICIT */ ? "-->" : "-.->";
+    const label = edge.type === "file_conflict" /* FILE_CONFLICT */ ? "|conflict|" : "";
+    lines.push(`  ${edge.from} ${style}${label} ${edge.to}`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/parallel.ts
+var PARALLEL_STATE_FILE = ".archon/parallel-state.json";
+async function loadParallelState(cwd) {
+  const statePath = join2(cwd, PARALLEL_STATE_FILE);
+  if (!existsSync2(statePath)) {
+    return { executions: [] };
+  }
+  const content = await readFile(statePath, "utf-8");
+  return JSON.parse(content);
+}
+async function saveParallelState(cwd, state) {
+  const statePath = join2(cwd, PARALLEL_STATE_FILE);
+  await writeFile(statePath, JSON.stringify(state, null, 2));
+}
+async function parallelExecute(atomIds) {
+  const cwd = process.cwd();
+  const manager = new WorktreeManager(cwd);
+  console.log(chalk.blue(`
+\u{1F680} Starting parallel execution of ${atomIds.length} atoms...
+`));
+  const state = await loadParallelState(cwd);
+  for (const atomId of atomIds) {
+    const atom = await loadAtom(atomId);
+    if (!atom) {
+      console.error(chalk.red(`Atom ${atomId} not found. Skipping.`));
+      continue;
+    }
+    if (atom.status !== "READY") {
+      console.log(chalk.yellow(`Atom ${atomId} is not READY (status: ${atom.status}). Skipping.`));
+      continue;
+    }
+    try {
+      console.log(chalk.dim(`Creating worktree for ${atomId}...`));
+      const worktreePath = await manager.createWorktree(atomId);
+      state.executions.push({
+        atomId,
+        worktreePath,
+        status: "pending"
+      });
+      console.log(chalk.green(`\u2713 Created worktree: ${worktreePath}`));
+    } catch (error) {
+      console.error(chalk.red(`Failed to create worktree for ${atomId}:`));
+      console.error(chalk.dim(error instanceof Error ? error.message : "Unknown error"));
+    }
+  }
+  await saveParallelState(cwd, state);
+  console.log(chalk.dim("\nStarting parallel execution..."));
+  const promises = state.executions.filter((e) => e.status === "pending").map(async (execution) => {
+    execution.status = "running";
+    execution.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveParallelState(cwd, state);
+    return new Promise((resolve) => {
+      const child = spawn("npx", ["archon", "execute", execution.atomId, "--skip-gates"], {
+        cwd: execution.worktreePath,
+        stdio: "pipe"
+      });
+      let output = "";
+      child.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        output += data.toString();
+      });
+      child.on("close", async (code) => {
+        execution.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (code === 0) {
+          execution.status = "completed";
+          console.log(chalk.green(`\u2713 ${execution.atomId} completed`));
+        } else {
+          execution.status = "failed";
+          execution.error = output.slice(-500);
+          console.log(chalk.red(`\u2717 ${execution.atomId} failed`));
+        }
+        await saveParallelState(cwd, state);
+        resolve();
+      });
+    });
+  });
+  await Promise.all(promises);
+  const completed = state.executions.filter((e) => e.status === "completed").length;
+  const failed = state.executions.filter((e) => e.status === "failed").length;
+  console.log(chalk.blue(`
+Parallel execution complete:`));
+  console.log(chalk.green(`  \u2713 Completed: ${completed}`));
+  if (failed > 0) {
+    console.log(chalk.red(`  \u2717 Failed: ${failed}`));
+  }
+  console.log(chalk.dim(`
+Run "archon parallel status" to see details.`));
+  console.log(chalk.dim(`Run "archon parallel merge" to merge completed worktrees.`));
+}
+async function parallelStatus() {
+  const cwd = process.cwd();
+  const state = await loadParallelState(cwd);
+  if (state.executions.length === 0) {
+    console.log(chalk.dim("No parallel executions found."));
+    return;
+  }
+  console.log(chalk.blue("\nParallel Execution Status\n"));
+  for (const execution of state.executions) {
+    const statusIcon = execution.status === "completed" ? chalk.green("\u2713") : execution.status === "failed" ? chalk.red("\u2717") : execution.status === "running" ? chalk.yellow("\u25CF") : chalk.dim("\u25CB");
+    console.log(`${statusIcon} ${execution.atomId}`);
+    console.log(chalk.dim(`   Path: ${execution.worktreePath}`));
+    console.log(chalk.dim(`   Status: ${execution.status}`));
+    if (execution.startedAt) {
+      console.log(chalk.dim(`   Started: ${execution.startedAt}`));
+    }
+    if (execution.completedAt) {
+      console.log(chalk.dim(`   Completed: ${execution.completedAt}`));
+    }
+    if (execution.error) {
+      console.log(chalk.red(`   Error: ${execution.error.slice(0, 100)}...`));
+    }
+    console.log();
+  }
+}
+async function parallelMerge(atomId) {
+  const cwd = process.cwd();
+  const manager = new WorktreeManager(cwd);
+  const state = await loadParallelState(cwd);
+  const toMerge = atomId ? state.executions.filter((e) => e.atomId === atomId && e.status === "completed") : state.executions.filter((e) => e.status === "completed");
+  if (toMerge.length === 0) {
+    console.log(chalk.yellow("No completed executions to merge."));
+    return;
+  }
+  console.log(chalk.blue(`
+\u{1F500} Merging ${toMerge.length} completed worktree(s)...
+`));
+  for (const execution of toMerge) {
+    try {
+      console.log(chalk.dim(`Merging ${execution.atomId}...`));
+      await manager.mergeWorktree(execution.atomId);
+      console.log(chalk.green(`\u2713 Merged ${execution.atomId}`));
+      console.log(chalk.dim(`Cleaning up worktree...`));
+      await manager.removeWorktree(execution.atomId);
+      console.log(chalk.green(`\u2713 Removed worktree for ${execution.atomId}`));
+      state.executions = state.executions.filter((e) => e.atomId !== execution.atomId);
+    } catch (error) {
+      console.error(chalk.red(`Failed to merge ${execution.atomId}:`));
+      console.error(chalk.dim(error instanceof Error ? error.message : "Unknown error"));
+      console.log(chalk.yellow("You may need to resolve merge conflicts manually."));
+    }
+  }
+  await saveParallelState(cwd, state);
+  console.log(chalk.green("\n\u2705 Merge complete!"));
+}
+async function parallelClean() {
+  const cwd = process.cwd();
+  const manager = new WorktreeManager(cwd);
+  const state = await loadParallelState(cwd);
+  console.log(chalk.blue("\n\u{1F9F9} Cleaning up parallel execution state...\n"));
+  for (const execution of state.executions) {
+    try {
+      if (manager.worktreeExists(execution.atomId)) {
+        console.log(chalk.dim(`Removing worktree for ${execution.atomId}...`));
+        await manager.removeWorktree(execution.atomId);
+        console.log(chalk.green(`\u2713 Removed worktree for ${execution.atomId}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Failed to remove worktree for ${execution.atomId}:`));
+      console.error(chalk.dim(error instanceof Error ? error.message : "Unknown error"));
+    }
+  }
+  await saveParallelState(cwd, { executions: [] });
+  console.log(chalk.green("\n\u2705 Cleanup complete!"));
+}
+function toSchedulableAtom(atom) {
+  return {
+    id: atom.id,
+    title: atom.title,
+    dependencies: atom.dependencies
+  };
+}
+async function parallelSchedule(options) {
+  const atoms = await listLocalAtoms();
+  if (atoms.length === 0) {
+    console.log(chalk.yellow('No atoms found. Run "archon plan" first.'));
+    return;
+  }
+  const targetAtoms = options.onlyReady ? atoms.filter((a) => a.status === "READY") : atoms;
+  if (targetAtoms.length === 0) {
+    console.log(chalk.yellow('No READY atoms found. Run "archon plan <atom-id>" first.'));
+    return;
+  }
+  console.log(chalk.blue(`
+\u{1F4CA} Analyzing ${targetAtoms.length} atom(s)...
+`));
+  const schedulableAtoms = targetAtoms.map(toSchedulableAtom);
+  const graph = buildDependencyGraph(schedulableAtoms);
+  const plan = scheduleExecution(graph, {
+    maxParallelism: options.maxParallelism
+  });
+  if (options.mermaid) {
+    console.log(chalk.dim("Mermaid Diagram:"));
+    console.log("```mermaid");
+    console.log(formatAsMermaid(graph));
+    console.log("```");
+    console.log();
+  }
+  console.log(formatExecutionPlan(plan));
+  console.log();
+  console.log(chalk.blue("Wave Details:\n"));
+  for (const wave of plan.waves) {
+    console.log(chalk.bold(`Wave ${wave.waveNumber}:`));
+    for (const atom of wave.atoms) {
+      const originalAtom = atoms.find((a) => a.id === atom.id);
+      const status = originalAtom?.status ?? "UNKNOWN";
+      const statusColor = status === "READY" ? chalk.green : status === "COMPLETED" ? chalk.blue : chalk.yellow;
+      console.log(`  ${statusColor("\u25CF")} ${atom.id}: ${atom.title} ${chalk.dim(`(${status})`)}`);
+    }
+    console.log();
+  }
+  const conflictEdges = graph.edges.filter((e) => e.type === "file_conflict");
+  if (conflictEdges.length > 0) {
+    console.log(chalk.yellow("\u26A0\uFE0F  File Conflict Dependencies:\n"));
+    for (const edge of conflictEdges) {
+      console.log(`  ${edge.from} \u2192 ${edge.to}`);
+      if (edge.reason) {
+        console.log(chalk.dim(`    ${edge.reason}`));
+      }
+    }
+    console.log();
+  }
+  console.log(chalk.dim("To execute atoms in parallel: archon parallel run <atom-ids...>"));
+  console.log(chalk.dim("To execute waves sequentially: archon parallel run-waves"));
+}
+async function parallelRunWaves(options) {
+  const atoms = await listLocalAtoms();
+  const readyAtoms = atoms.filter((a) => a.status === "READY");
+  if (readyAtoms.length === 0) {
+    console.log(chalk.yellow("No READY atoms found."));
+    return;
+  }
+  const schedulableAtoms = readyAtoms.map(toSchedulableAtom);
+  const graph = buildDependencyGraph(schedulableAtoms);
+  const plan = scheduleExecution(graph, { maxParallelism: options.maxParallelism });
+  console.log(chalk.blue(`
+\u{1F680} Executing ${plan.totalAtoms} atoms in ${plan.waves.length} waves
+`));
+  console.log(chalk.dim(`Estimated speedup: ${plan.estimatedSpeedup}\xD7 vs serial execution
+`));
+  if (options.dryRun) {
+    console.log(chalk.yellow("DRY RUN - no atoms will be executed\n"));
+    console.log(formatExecutionPlan(plan));
+    return;
+  }
+  const cwd = process.cwd();
+  const manager = new WorktreeManager(cwd);
+  for (const wave of plan.waves) {
+    console.log(chalk.blue(`
+\u2550\u2550\u2550 Wave ${wave.waveNumber} (${wave.atoms.length} atoms) \u2550\u2550\u2550
+`));
+    const worktrees = [];
+    for (const atom of wave.atoms) {
+      try {
+        const worktreePath = await manager.createWorktree(atom.id);
+        worktrees.push({ atomId: atom.id, path: worktreePath });
+        console.log(chalk.dim(`  Created worktree for ${atom.id}`));
+      } catch (error) {
+        console.error(chalk.red(`  Failed to create worktree for ${atom.id}:`));
+        console.error(chalk.dim(error instanceof Error ? error.message : "Unknown error"));
+      }
+    }
+    const results = await Promise.all(
+      worktrees.map(({ atomId, path }) => executeAtomInWorktree(atomId, path))
+    );
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    console.log();
+    console.log(chalk.green(`  \u2713 ${succeeded} succeeded`));
+    if (failed > 0) {
+      console.log(chalk.red(`  \u2717 ${failed} failed`));
+    }
+    for (const result of results) {
+      if (result.success) {
+        try {
+          await manager.mergeWorktree(result.atomId);
+          await manager.removeWorktree(result.atomId);
+          console.log(chalk.dim(`  Merged and cleaned ${result.atomId}`));
+        } catch (error) {
+          console.error(chalk.yellow(`  Failed to merge ${result.atomId} - manual merge may be required`));
+        }
+      }
+    }
+    if (failed > 0) {
+      console.log(chalk.red("\n\u26A0\uFE0F  Wave had failures. Stopping execution."));
+      console.log(chalk.dim("Fix the issues and run again to continue."));
+      return;
+    }
+  }
+  console.log(chalk.green("\n\u2705 All waves completed successfully!"));
+}
+async function executeAtomInWorktree(atomId, worktreePath) {
+  return new Promise((resolve) => {
+    const child = spawn("npx", ["archon", "execute", atomId, "--skip-gates"], {
+      cwd: worktreePath,
+      stdio: "pipe"
+    });
+    let output = "";
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ atomId, success: true });
+      } else {
+        resolve({ atomId, success: false, error: output.slice(-500) });
+      }
+    });
+    child.on("error", (error) => {
+      resolve({ atomId, success: false, error: error.message });
+    });
+  });
+}
+
+export {
+  parallelExecute,
+  parallelStatus,
+  parallelMerge,
+  parallelClean,
+  parallelSchedule,
+  parallelRunWaves
+};

package/dist/{execute-6D6USH33.js → execute-465TGOYD.js}

@@ -1,6 +1,6 @@
 import {
   execute
-} from "./chunk-HGO4UUAC.js";
+} from "./chunk-6TCM6JYX.js";
 import "./chunk-M4LGRTLC.js";
 import "./chunk-5HVYNCLT.js";
 import "./chunk-5IQKC2TD.js";