archondev 3.0.1 → 3.1.0

package/dist/chunk-EV5QU5KG.js

@@ -0,0 +1,18 @@
+// src/cli/retired-remote.ts
+import chalk from "chalk";
+function printRetiredRemotePath(featureName) {
+  console.log(chalk.yellow(`${featureName} has been retired.`));
+  console.log(chalk.dim("ArchonDev now runs as Free download/governance mode or local BYOK CLI AI."));
+  console.log(chalk.dim("Use local provider keys with: archon config ai"));
+  console.log(chalk.dim("View local BYOK usage with: archon usage"));
+}
+function retiredRemoteError(featureName) {
+  return new Error(
+    `${featureName} has been retired. Run locally with BYOK keys instead.`
+  );
+}
+
+export {
+  printRetiredRemotePath,
+  retiredRemoteError
+};

package/dist/{chunk-45T2VB5R.js → chunk-IZFUFXDN.js}

@@ -1,21 +1,17 @@
 import {
-  createAuthedSupabaseClient
-} from "./chunk-Q3GIFHIQ.js";
+  printRetiredRemotePath,
+  retiredRemoteError
+} from "./chunk-EV5QU5KG.js";
 import {
   listLocalAtoms,
   loadAtom
-} from "./chunk-7RXZTPXY.js";
+} from "./chunk-BSG5XY3C.js";
 import {
-  SUPABASE_ANON_KEY,
-  SUPABASE_URL
-} from "./chunk-M4LGRTLC.js";
-import {
-  getAuthToken,
   loadConfig
-} from "./chunk-GGRW4NTA.js";
+} from "./chunk-NQBS7L2F.js";
 
 // src/cli/parallel.ts
-import chalk2 from "chalk";
+import chalk from "chalk";
 import { spawn } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { readFile, writeFile } from "fs/promises";
@@ -357,139 +353,21 @@ function formatAsMermaid(graph) {
 }
 
 // src/cli/cloud.ts
-import chalk from "chalk";
-function getClient(accessToken) {
-  return createAuthedSupabaseClient(SUPABASE_URL, SUPABASE_ANON_KEY, accessToken);
-}
+import { execSync as execSync2 } from "child_process";
 async function cloudStatus() {
-  const config = await loadConfig();
-  const authToken = getAuthToken(config);
-  if (!authToken) {
-    console.error(chalk.red('Not authenticated. Run "archon login" first.'));
-    process.exit(1);
-  }
-  const client = getClient(authToken);
-  const { data, error } = await client.from("cloud_executions").select("*").order("created_at", { ascending: false }).limit(20);
-  if (error) {
-    console.error(chalk.red("Failed to fetch cloud executions:"), error.message);
-    process.exit(1);
-  }
-  if (!data || data.length === 0) {
-    console.log(chalk.dim("No cloud executions found."));
-    return;
-  }
-  console.log(chalk.bold("\nCloud Executions:\n"));
-  for (const exec of data) {
-    const statusIcon = getStatusIcon(exec.status);
-    const duration = exec.compute_minutes ? `${exec.compute_minutes} min` : "-";
-    console.log(`${statusIcon} ${chalk.bold(exec.id.slice(0, 8))} - ${exec.atom_id}`);
-    console.log(chalk.dim(`   Project: ${exec.project_name ?? "unknown"}`));
-    console.log(chalk.dim(`   Status: ${exec.status} | Duration: ${duration}`));
-    if (exec.result_branch) {
-      console.log(chalk.dim(`   Branch: ${exec.result_branch}`));
-    }
-    if (exec.result_pr_url) {
-      console.log(chalk.dim(`   PR: ${exec.result_pr_url}`));
-    }
-    if (exec.error_message) {
-      console.log(chalk.red(`   Error: ${exec.error_message}`));
-    }
-    console.log();
-  }
+  printRetiredRemotePath("Cloud execution");
 }
-async function cloudCancel(executionId) {
-  const config = await loadConfig();
-  const authToken = getAuthToken(config);
-  if (!authToken) {
-    console.error(chalk.red('Not authenticated. Run "archon login" first.'));
-    process.exit(1);
-  }
-  const client = getClient(authToken);
-  const { data: existing, error: fetchError } = await client.from("cloud_executions").select("id, status").eq("id", executionId).single();
-  if (fetchError || !existing) {
-    console.error(chalk.red(`Execution ${executionId} not found.`));
-    process.exit(1);
-  }
-  if (existing.status === "completed" || existing.status === "failed" || existing.status === "cancelled") {
-    console.log(chalk.yellow(`Execution is already ${existing.status}. Cannot cancel.`));
-    return;
-  }
-  const { error } = await client.from("cloud_executions").update({ status: "cancelled" }).eq("id", executionId);
-  if (error) {
-    console.error(chalk.red("Failed to cancel execution:"), error.message);
-    process.exit(1);
-  }
-  console.log(chalk.green(`\u2713 Execution ${executionId.slice(0, 8)} cancelled.`));
+async function cloudCancel(_executionId) {
+  printRetiredRemotePath("Cloud execution");
 }
-async function cloudLogs(executionId) {
-  const config = await loadConfig();
-  const authToken = getAuthToken(config);
-  if (!authToken) {
-    console.error(chalk.red('Not authenticated. Run "archon login" first.'));
-    process.exit(1);
-  }
-  const client = getClient(authToken);
-  const { data, error } = await client.from("cloud_executions").select("id, atom_id, status, logs").eq("id", executionId).single();
-  if (error || !data) {
-    console.error(chalk.red(`Execution ${executionId} not found.`));
-    process.exit(1);
-  }
-  const exec = data;
-  console.log(chalk.bold(`
-Logs for ${exec.id.slice(0, 8)} (${exec.atom_id}):
-`));
-  console.log(chalk.dim(`Status: ${exec.status}
-`));
-  const logs = exec.logs;
-  if (!logs || logs.length === 0) {
-    console.log(chalk.dim("No logs available yet."));
-    return;
-  }
-  for (const log of logs) {
-    const ts = log.timestamp ? chalk.dim(`[${log.timestamp}]`) : "";
-    const level = log.level === "error" ? chalk.red("ERROR") : log.level === "warn" ? chalk.yellow("WARN") : chalk.dim("INFO");
-    console.log(`${ts} ${level} ${log.message}`);
-  }
+async function cloudLogs(_executionId) {
+  printRetiredRemotePath("Cloud execution");
 }
-async function queueCloudExecution(atomId, projectName, options) {
-  const config = await loadConfig();
-  const authToken = getAuthToken(config);
-  if (!authToken) {
-    throw new Error('Not authenticated. Run "archon login" first.');
-  }
-  const client = getClient(authToken);
-  if (config.userId) {
-    const { data: profile, error: profileError } = await client.from("user_profiles").select("tier").eq("auth_id", config.userId).single();
-    if (profileError || !profile) {
-      throw new Error("Unable to verify billing tier. Try again or re-login.");
-    }
-    if (profile.tier !== "CREDITS") {
-      throw new Error("Cloud execution requires Credits tier. BYOK and Free run locally.");
-    }
-  }
-  const insertData = {
-    atom_id: atomId,
-    project_name: projectName,
-    status: "queued"
-  };
-  if (options?.repoUrl) {
-    insertData["repo_url"] = options.repoUrl;
-  }
-  if (options?.repoBranch) {
-    insertData["repo_branch"] = options.repoBranch;
-  }
-  if (options?.atomData) {
-    insertData["atom_data"] = options.atomData;
-  }
-  const { data, error } = await client.from("cloud_executions").insert(insertData).select("id").single();
-  if (error) {
-    throw new Error(`Failed to queue execution: ${error.message}`);
-  }
-  return data.id;
+async function queueCloudExecution(_atomId, _projectName, _options) {
+  throw retiredRemoteError("Cloud execution");
 }
 async function getGitRemoteUrl(cwd = process.cwd()) {
   try {
-    const { execSync: execSync2 } = await import("child_process");
     const output = execSync2("git remote get-url origin", { cwd, encoding: "utf-8" });
     return output.trim();
   } catch {
@@ -498,29 +376,12 @@ async function getGitRemoteUrl(cwd = process.cwd()) {
 }
 async function getGitBranch(cwd = process.cwd()) {
   try {
-    const { execSync: execSync2 } = await import("child_process");
     const output = execSync2("git branch --show-current", { cwd, encoding: "utf-8" });
     return output.trim() || "main";
   } catch {
     return "main";
   }
 }
-function getStatusIcon(status) {
-  switch (status) {
-    case "queued":
-      return chalk.blue("\u23F3");
-    case "running":
-      return chalk.yellow("\u{1F504}");
-    case "completed":
-      return chalk.green("\u2713");
-    case "failed":
-      return chalk.red("\u2717");
-    case "cancelled":
-      return chalk.gray("\u2298");
-    default:
-      return chalk.dim("?");
-  }
-}
 
 // src/cli/parallel.ts
 var PARALLEL_STATE_FILE = ".archon/parallel-state.json";
@@ -539,36 +400,36 @@ async function saveParallelState(cwd, state) {
 async function parallelExecute(atomIds, options = {}) {
   const cwd = process.cwd();
   const manager = new WorktreeManager(cwd);
-  console.log(chalk2.blue(`
+  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(chalk2.red(`Atom ${atomId} not found. Skipping.`));
+      console.error(chalk.red(`Atom ${atomId} not found. Skipping.`));
       continue;
     }
     if (atom.status !== "READY") {
-      console.log(chalk2.yellow(`Atom ${atomId} is not READY (status: ${atom.status}). Skipping.`));
+      console.log(chalk.yellow(`Atom ${atomId} is not READY (status: ${atom.status}). Skipping.`));
       continue;
     }
     try {
-      console.log(chalk2.dim(`Creating worktree for ${atomId}...`));
+      console.log(chalk.dim(`Creating worktree for ${atomId}...`));
       const worktreePath = await manager.createWorktree(atomId);
       state.executions.push({
         atomId,
         worktreePath,
         status: "pending"
       });
-      console.log(chalk2.green(`\u2713 Created worktree: ${worktreePath}`));
+      console.log(chalk.green(`\u2713 Created worktree: ${worktreePath}`));
     } catch (error) {
-      console.error(chalk2.red(`Failed to create worktree for ${atomId}:`));
-      console.error(chalk2.dim(error instanceof Error ? error.message : "Unknown 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(chalk2.dim("\nStarting parallel execution..."));
+  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();
@@ -593,11 +454,11 @@ async function parallelExecute(atomIds, options = {}) {
         execution.completedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (code === 0) {
           execution.status = "completed";
-          console.log(chalk2.green(`\u2713 ${execution.atomId} completed`));
+          console.log(chalk.green(`\u2713 ${execution.atomId} completed`));
         } else {
           execution.status = "failed";
           execution.error = output.slice(-500);
-          console.log(chalk2.red(`\u2717 ${execution.atomId} failed`));
+          console.log(chalk.red(`\u2717 ${execution.atomId} failed`));
         }
         await saveParallelState(cwd, state);
         resolve();
@@ -607,46 +468,46 @@ async function parallelExecute(atomIds, options = {}) {
   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(chalk2.blue(`
+  console.log(chalk.blue(`
 Parallel execution complete:`));
-  console.log(chalk2.green(`  \u2713 Completed: ${completed}`));
+  console.log(chalk.green(`  \u2713 Completed: ${completed}`));
   if (failed > 0) {
-    console.log(chalk2.red(`  \u2717 Failed: ${failed}`));
+    console.log(chalk.red(`  \u2717 Failed: ${failed}`));
   }
-  console.log(chalk2.dim(`
+  console.log(chalk.dim(`
 Run "archon parallel status" to see details.`));
-  console.log(chalk2.dim(`Run "archon parallel merge" to merge completed worktrees.`));
+  console.log(chalk.dim(`Run "archon parallel merge" to merge completed worktrees.`));
 }
 async function parallelExecuteCloud(atomIds) {
   const cwd = process.cwd();
   const config = await loadConfig();
   const tier = config.tier ?? "FREE";
-  if (tier !== "CREDITS") {
-    console.log(chalk2.red("\n\u274C Cloud execution requires Credits tier"));
-    console.log(chalk2.dim("BYOK and Free tiers run locally only."));
-    console.log(chalk2.dim("Upgrade with: archon upgrade"));
+  if (tier === "FREE" || tier === "BYOK") {
+    console.log(chalk.red("\nCloud execution is retired in the Free/BYOK model."));
+    console.log(chalk.dim("Free mode and BYOK mode run locally only."));
+    console.log(chalk.dim("Run without cloud execution to use your local provider keys."));
     process.exit(1);
   }
   const projectName = basename(cwd);
   const repoUrl = await getGitRemoteUrl(cwd);
   const repoBranch = await getGitBranch(cwd);
   if (!repoUrl) {
-    console.error(chalk2.red("No git remote found. Cloud execution requires a GitHub repository."));
-    console.log(chalk2.dim("Add a remote with: git remote add origin <url>"));
+    console.error(chalk.red("No git remote found. Cloud execution requires a GitHub repository."));
+    console.log(chalk.dim("Add a remote with: git remote add origin <url>"));
     process.exit(1);
   }
-  console.log(chalk2.blue(`
+  console.log(chalk.blue(`
 \u2601\uFE0F  Queueing ${atomIds.length} cloud execution(s)...
 `));
   const queued = [];
   for (const atomId of atomIds) {
     const atom = await loadAtom(atomId);
     if (!atom) {
-      console.error(chalk2.red(`Atom ${atomId} not found. Skipping.`));
+      console.error(chalk.red(`Atom ${atomId} not found. Skipping.`));
       continue;
     }
     if (atom.status !== "READY") {
-      console.log(chalk2.yellow(`Atom ${atomId} is not READY (status: ${atom.status}). Skipping.`));
+      console.log(chalk.yellow(`Atom ${atomId} is not READY (status: ${atom.status}). Skipping.`));
       continue;
     }
     try {
@@ -656,42 +517,42 @@ async function parallelExecuteCloud(atomIds) {
         atomData: atom
       });
       queued.push({ atomId, executionId });
-      console.log(chalk2.green(`\u2713 ${atomId} queued (${executionId.slice(0, 8)})`));
+      console.log(chalk.green(`\u2713 ${atomId} queued (${executionId.slice(0, 8)})`));
     } catch (error) {
-      console.error(chalk2.red(`Failed to queue ${atomId}:`));
-      console.error(chalk2.dim(error instanceof Error ? error.message : "Unknown error"));
+      console.error(chalk.red(`Failed to queue ${atomId}:`));
+      console.error(chalk.dim(error instanceof Error ? error.message : "Unknown error"));
     }
   }
   if (queued.length === 0) {
-    console.log(chalk2.dim("\nNo executions were queued."));
+    console.log(chalk.dim("\nNo executions were queued."));
     return;
   }
-  console.log(chalk2.dim("\nCheck progress with:"));
-  console.log(chalk2.bold("  archon cloud status"));
-  console.log(chalk2.dim("View logs with:"));
-  console.log(chalk2.bold("  archon cloud logs <id>"));
+  console.log(chalk.dim("\nCheck progress with:"));
+  console.log(chalk.bold("  archon cloud status"));
+  console.log(chalk.dim("View logs with:"));
+  console.log(chalk.bold("  archon cloud logs <id>"));
 }
 async function parallelStatus() {
   const cwd = process.cwd();
   const state = await loadParallelState(cwd);
   if (state.executions.length === 0) {
-    console.log(chalk2.dim("No parallel executions found."));
+    console.log(chalk.dim("No parallel executions found."));
     return;
   }
-  console.log(chalk2.blue("\nParallel Execution Status\n"));
+  console.log(chalk.blue("\nParallel Execution Status\n"));
   for (const execution of state.executions) {
-    const statusIcon = execution.status === "completed" ? chalk2.green("\u2713") : execution.status === "failed" ? chalk2.red("\u2717") : execution.status === "running" ? chalk2.yellow("\u25CF") : chalk2.dim("\u25CB");
+    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(chalk2.dim(`   Path: ${execution.worktreePath}`));
-    console.log(chalk2.dim(`   Status: ${execution.status}`));
+    console.log(chalk.dim(`   Path: ${execution.worktreePath}`));
+    console.log(chalk.dim(`   Status: ${execution.status}`));
     if (execution.startedAt) {
-      console.log(chalk2.dim(`   Started: ${execution.startedAt}`));
+      console.log(chalk.dim(`   Started: ${execution.startedAt}`));
     }
     if (execution.completedAt) {
-      console.log(chalk2.dim(`   Completed: ${execution.completedAt}`));
+      console.log(chalk.dim(`   Completed: ${execution.completedAt}`));
     }
     if (execution.error) {
-      console.log(chalk2.red(`   Error: ${execution.error.slice(0, 100)}...`));
+      console.log(chalk.red(`   Error: ${execution.error.slice(0, 100)}...`));
     }
     console.log();
   }
@@ -702,49 +563,49 @@ async function parallelMerge(atomId) {
   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(chalk2.yellow("No completed executions to merge."));
+    console.log(chalk.yellow("No completed executions to merge."));
     return;
   }
-  console.log(chalk2.blue(`
+  console.log(chalk.blue(`
 \u{1F500} Merging ${toMerge.length} completed worktree(s)...
 `));
   for (const execution of toMerge) {
     try {
-      console.log(chalk2.dim(`Merging ${execution.atomId}...`));
+      console.log(chalk.dim(`Merging ${execution.atomId}...`));
       await manager.mergeWorktree(execution.atomId);
-      console.log(chalk2.green(`\u2713 Merged ${execution.atomId}`));
-      console.log(chalk2.dim(`Cleaning up worktree...`));
+      console.log(chalk.green(`\u2713 Merged ${execution.atomId}`));
+      console.log(chalk.dim(`Cleaning up worktree...`));
       await manager.removeWorktree(execution.atomId);
-      console.log(chalk2.green(`\u2713 Removed worktree for ${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(chalk2.red(`Failed to merge ${execution.atomId}:`));
-      console.error(chalk2.dim(error instanceof Error ? error.message : "Unknown error"));
-      console.log(chalk2.yellow("You may need to resolve merge conflicts manually."));
+      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(chalk2.green("\n\u2705 Merge complete!"));
+  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(chalk2.blue("\n\u{1F9F9} Cleaning up parallel execution state...\n"));
+  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(chalk2.dim(`Removing worktree for ${execution.atomId}...`));
+        console.log(chalk.dim(`Removing worktree for ${execution.atomId}...`));
         await manager.removeWorktree(execution.atomId);
-        console.log(chalk2.green(`\u2713 Removed worktree for ${execution.atomId}`));
+        console.log(chalk.green(`\u2713 Removed worktree for ${execution.atomId}`));
       }
     } catch (error) {
-      console.error(chalk2.red(`Failed to remove worktree for ${execution.atomId}:`));
-      console.error(chalk2.dim(error instanceof Error ? error.message : "Unknown 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(chalk2.green("\n\u2705 Cleanup complete!"));
+  console.log(chalk.green("\n\u2705 Cleanup complete!"));
 }
 function toSchedulableAtom(atom) {
   return {
@@ -757,15 +618,15 @@ function toSchedulableAtom(atom) {
 async function parallelSchedule(options) {
   const atoms = await listLocalAtoms();
   if (atoms.length === 0) {
-    console.log(chalk2.yellow('No atoms found. Run "archon plan" first.'));
+    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(chalk2.yellow('No READY atoms found. Run "archon plan <atom-id>" first.'));
+    console.log(chalk.yellow('No READY atoms found. Run "archon plan <atom-id>" first.'));
     return;
   }
-  console.log(chalk2.blue(`
+  console.log(chalk.blue(`
 \u{1F4CA} Analyzing ${targetAtoms.length} atom(s)...
 `));
   const schedulableAtoms = targetAtoms.map(toSchedulableAtom);
@@ -774,7 +635,7 @@ async function parallelSchedule(options) {
     maxParallelism: options.maxParallelism
   });
   if (options.mermaid) {
-    console.log(chalk2.dim("Mermaid Diagram:"));
+    console.log(chalk.dim("Mermaid Diagram:"));
     console.log("```mermaid");
     console.log(formatAsMermaid(graph));
     console.log("```");
@@ -782,30 +643,30 @@ async function parallelSchedule(options) {
   }
   console.log(formatExecutionPlan(plan));
   console.log();
-  console.log(chalk2.blue("Wave Details:\n"));
+  console.log(chalk.blue("Wave Details:\n"));
   for (const wave of plan.waves) {
-    console.log(chalk2.bold(`Wave ${wave.waveNumber}:`));
+    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" ? chalk2.green : status === "DONE" ? chalk2.blue : chalk2.yellow;
-      console.log(`  ${statusColor("\u25CF")} ${atom.id}: ${atom.title} ${chalk2.dim(`(${status})`)}`);
+      const statusColor = status === "READY" ? chalk.green : status === "DONE" ? 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(chalk2.yellow("\u26A0\uFE0F  File Conflict Dependencies:\n"));
+    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(chalk2.dim(`    ${edge.reason}`));
+        console.log(chalk.dim(`    ${edge.reason}`));
       }
     }
     console.log();
   }
-  console.log(chalk2.dim("To execute atoms in parallel: archon parallel run <atom-ids...>"));
-  console.log(chalk2.dim("To execute waves sequentially: archon parallel run-waves"));
+  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();
@@ -815,29 +676,29 @@ async function parallelRunWaves(options) {
   );
   if (readyAtoms.length === 0) {
     if (scopeIds && scopeIds.size > 0) {
-      console.log(chalk2.yellow("No READY atoms found in the approved scope."));
+      console.log(chalk.yellow("No READY atoms found in the approved scope."));
       return;
     }
-    console.log(chalk2.yellow("No READY atoms found."));
+    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(chalk2.blue(`
+  console.log(chalk.blue(`
 \u{1F680} Executing ${plan.totalAtoms} atoms in ${plan.waves.length} waves
 `));
-  console.log(chalk2.dim(`Estimated speedup: ${plan.estimatedSpeedup}\xD7 vs serial execution
+  console.log(chalk.dim(`Estimated speedup: ${plan.estimatedSpeedup}\xD7 vs serial execution
 `));
   if (options.dryRun) {
-    console.log(chalk2.yellow("DRY RUN - no atoms will be executed\n"));
+    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(chalk2.blue(`
+    console.log(chalk.blue(`
 \u2550\u2550\u2550 Wave ${wave.waveNumber} (${wave.atoms.length} atoms) \u2550\u2550\u2550
 `));
     const worktrees = [];
@@ -845,10 +706,10 @@ async function parallelRunWaves(options) {
       try {
         const worktreePath = await manager.createWorktree(atom.id);
         worktrees.push({ atomId: atom.id, path: worktreePath });
-        console.log(chalk2.dim(`  Created worktree for ${atom.id}`));
+        console.log(chalk.dim(`  Created worktree for ${atom.id}`));
       } catch (error) {
-        console.error(chalk2.red(`  Failed to create worktree for ${atom.id}:`));
-        console.error(chalk2.dim(error instanceof Error ? error.message : "Unknown 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(
@@ -857,28 +718,28 @@ async function parallelRunWaves(options) {
     const succeeded = results.filter((r) => r.success).length;
     const failed = results.filter((r) => !r.success).length;
     console.log();
-    console.log(chalk2.green(`  \u2713 ${succeeded} succeeded`));
+    console.log(chalk.green(`  \u2713 ${succeeded} succeeded`));
     if (failed > 0) {
-      console.log(chalk2.red(`  \u2717 ${failed} failed`));
+      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(chalk2.dim(`  Merged and cleaned ${result.atomId}`));
+          console.log(chalk.dim(`  Merged and cleaned ${result.atomId}`));
         } catch (error) {
-          console.error(chalk2.yellow(`  Failed to merge ${result.atomId} - manual merge may be required`));
+          console.error(chalk.yellow(`  Failed to merge ${result.atomId} - manual merge may be required`));
         }
       }
     }
     if (failed > 0) {
-      console.log(chalk2.red("\n\u26A0\uFE0F  Wave had failures. Stopping execution."));
-      console.log(chalk2.dim("Fix the issues and run again to continue."));
+      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(chalk2.green("\n\u2705 All waves completed successfully!"));
+  console.log(chalk.green("\n\u2705 All waves completed successfully!"));
 }
 async function executeAtomInWorktree(atomId, worktreePath) {
   return new Promise((resolve) => {