quadwork 0.1.2 → 1.0.0

package/bin/quadwork.js

@@ -11,7 +11,7 @@ const readline = require("readline");
 const CONFIG_DIR = path.join(os.homedir(), ".quadwork");
 const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 const TEMPLATES_DIR = path.join(__dirname, "..", "templates");
-const AGENTS = ["t1", "t2a", "t2b", "t3"];
+const AGENTS = ["head", "reviewer1", "reviewer2", "dev"];
 
 // ─── ANSI Helpers ──────────────────────────────────────────────────────────
 
@@ -123,9 +123,33 @@ function askYN(rl, question, defaultYes = false) {
   });
 }
 
+// Migration: rename old agent keys to new ones
+const AGENT_KEY_MAP = { t1: "head", t2a: "reviewer1", t2b: "reviewer2", t3: "dev" };
+
+function migrateAgentKeys(config) {
+  let changed = false;
+  if (config.projects) {
+    for (const project of config.projects) {
+      if (!project.agents) continue;
+      for (const [oldKey, newKey] of Object.entries(AGENT_KEY_MAP)) {
+        if (project.agents[oldKey] && !project.agents[newKey]) {
+          project.agents[newKey] = project.agents[oldKey];
+          delete project.agents[oldKey];
+          changed = true;
+        }
+      }
+    }
+  }
+  if (changed) {
+    try { writeConfig(config); } catch {}
+  }
+  return config;
+}
+
 function readConfig() {
   try {
-    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    return migrateAgentKeys(config);
   } catch {
     return { port: 8400, agentchattr_url: "http://127.0.0.1:8300", projects: [] };
   }
@@ -140,46 +164,295 @@ function writeConfig(config) {
 
 let agentChattrFound = false;
 
-function checkPrereqs() {
+function detectPlatform() {
+  const p = os.platform();
+  if (p === "darwin") return "macos";
+  if (p === "linux") {
+    // Check for apt vs dnf vs yum
+    if (which("apt")) return "linux-apt";
+    if (which("dnf")) return "linux-dnf";
+    if (which("yum")) return "linux-yum";
+    return "linux";
+  }
+  return "other";
+}
+
+async function tryInstall(rl, name, description, commands, { platform } = {}) {
+  const cmd = typeof commands === "function" ? commands(platform) : commands;
+  if (!cmd) {
+    warn(`${name} cannot be auto-installed on your system.`);
+    return false;
+  }
+  console.log("");
+  log(`${description}`);
+  const doInstall = await askYN(rl, `Install ${name} now?`, true);
+  if (!doInstall) {
+    log("Skipped.");
+    return false;
+  }
+  const sp = spinner(`Installing ${name}...`);
+  const result = run(`${cmd} 2>&1`, { timeout: 120000 });
+  if (result !== null) {
+    sp.stop(true);
+    return true;
+  } else {
+    sp.stop(false);
+    warn(`Auto-install failed. You can install manually and try again.`);
+    return false;
+  }
+}
+
+async function checkPrereqs(rl) {
   header("Step 1: Prerequisites");
+  const platform = detectPlatform();
   let allOk = true;
+  let hasPython = false;
+  let hasPipx = false;
 
-  // Node.js 20+
+  // ── 1. Node.js 20+ (must already exist — user ran npx) ──
   const nodeVer = run("node --version");
   if (nodeVer) {
     const major = parseInt(nodeVer.replace("v", "").split(".")[0], 10);
-    if (major >= 20) ok(`Node.js ${nodeVer}`);
-    else { fail(`Node.js ${nodeVer} — need 20+`); allOk = false; }
-  } else { fail("Node.js not found"); allOk = false; }
+    if (major >= 20) {
+      ok(`Node.js ${nodeVer}`);
+    } else {
+      fail(`Node.js ${nodeVer} — version 20 or newer is required`);
+      log("Update from: https://nodejs.org");
+      allOk = false;
+    }
+  } else {
+    fail("Node.js not found (this shouldn't happen since you ran npx)");
+    allOk = false;
+  }
 
-  // Python 3.10+
+  // ── 2. Python 3.10+ (manual install — guide only) ──
   const pyVer = run("python3 --version");
   if (pyVer) {
     const parts = pyVer.replace("Python ", "").split(".");
     const minor = parseInt(parts[1], 10);
-    if (parseInt(parts[0], 10) >= 3 && minor >= 10) ok(`${pyVer}`);
-    else { fail(`${pyVer} — need 3.10+`); allOk = false; }
-  } else { fail("Python 3 not found"); allOk = false; }
+    if (parseInt(parts[0], 10) >= 3 && minor >= 10) {
+      ok(`${pyVer}`);
+      hasPython = true;
+    } else {
+      console.log("");
+      warn(`${pyVer} found, but version 3.10 or newer is required.`);
+      log("Python powers the agent communication layer.");
+      log("Download the latest version from:");
+      log(`  → https://python.org/downloads`);
+      log("");
+      log("After installing, close and reopen your terminal, then run:");
+      log("  → npx quadwork init");
+      allOk = false;
+    }
+  } else {
+    console.log("");
+    warn("Python 3 is required but not installed on your system.");
+    log("");
+    log("Python powers the agent communication layer. Install it from:");
+    log("  → https://python.org/downloads (download and run the installer)");
+    log("");
+    log("After installing, close and reopen your terminal, then run:");
+    log("  → npx quadwork init");
+    allOk = false;
+  }
+
+  if (!hasPython) {
+    // Can't continue with pipx/AgentChattr without Python
+    console.log("");
+    fail("Python is required before we can set up the remaining tools.");
+    log("Install Python first, then re-run: npx quadwork init");
+    return false;
+  }
 
-  // AgentChattr
+  // ── 3. pipx (needs Python) ──
+  if (which("pipx")) {
+    ok("pipx");
+    hasPipx = true;
+  } else {
+    console.log("");
+    warn("pipx is needed to install AgentChattr safely.");
+    log("(pipx keeps Python tools isolated so they don't conflict with your system)");
+    const installed = await tryInstall(rl, "pipx", "We can install it automatically.",
+      "python3 -m pip install --user pipx && python3 -m pipx ensurepath");
+    if (installed && which("pipx")) {
+      ok("pipx installed");
+      hasPipx = true;
+    } else if (installed) {
+      // pipx installed but not in PATH yet
+      warn("pipx was installed but isn't in your PATH yet.");
+      log("Close and reopen your terminal, then run: npx quadwork init");
+      return false;
+    } else {
+      warn("pipx skipped — you can install it later:");
+      log("  → python3 -m pip install --user pipx && pipx ensurepath");
+    }
+  }
+
+  // ── 4. AgentChattr (needs pipx) ──
   const acVer = run("agentchattr --version") || run("python3 -m agentchattr --version");
-  if (acVer) { ok(`AgentChattr ${acVer}`); agentChattrFound = true; }
-  else { warn("AgentChattr not found — install: pip install agentchattr"); allOk = false; }
+  if (acVer) {
+    ok(`AgentChattr ${acVer}`);
+    agentChattrFound = true;
+  } else if (hasPipx) {
+    console.log("");
+    warn("AgentChattr lets your AI agents communicate with each other.");
+    const installed = await tryInstall(rl, "AgentChattr",
+      "We can install it now using pipx.", "pipx install agentchattr");
+    const acVerAfter = run("agentchattr --version") || run("python3 -m agentchattr --version");
+    if (acVerAfter) {
+      ok(`AgentChattr ${acVerAfter} installed`);
+      agentChattrFound = true;
+    } else {
+      warn("AgentChattr not available — agents won't be able to chat until it's installed.");
+      log("  → Install later: pipx install agentchattr");
+      allOk = false;
+    }
+  } else {
+    warn("AgentChattr not found — install pipx first, then: pipx install agentchattr");
+    allOk = false;
+  }
 
-  // gh CLI
-  if (which("gh")) ok("GitHub CLI (gh)");
-  else { fail("GitHub CLI not found — install: https://cli.github.com"); allOk = false; }
+  // ── 5. GitHub CLI (independent) ──
+  if (which("gh")) {
+    ok("GitHub CLI (gh)");
+  } else {
+    console.log("");
+    warn("GitHub CLI is required for agents to create branches, PRs, and reviews.");
+    const ghCmd = (p) => {
+      if (p === "macos") return "brew install gh";
+      if (p === "linux-apt") return "sudo apt install gh -y";
+      if (p === "linux-dnf") return "sudo dnf install gh -y";
+      return null;
+    };
+    const cmd = ghCmd(platform);
+    if (cmd) {
+      const installed = await tryInstall(rl, "GitHub CLI",
+        "We can install it now.", ghCmd, { platform });
+      if (installed && which("gh")) {
+        ok("GitHub CLI installed");
+      } else {
+        fail("GitHub CLI is required. Install from: https://cli.github.com");
+        allOk = false;
+      }
+    } else {
+      fail("GitHub CLI is required. Install from: https://cli.github.com");
+      allOk = false;
+    }
+  }
+
+  // ── 6. AI CLIs — at least one required (independent) ──
+  let hasClaude = which("claude");
+  let hasCodex = which("codex");
 
-  // Claude Code or Codex
-  const hasClaude = which("claude");
-  const hasCodex = which("codex");
   if (hasClaude) ok("Claude Code");
   if (hasCodex) ok("Codex CLI");
+
+  if (!hasClaude && !hasCodex) {
+    console.log("");
+    warn("You need at least one AI CLI to power your agents.");
+    log("Choose one (or both) to install:");
+    console.log("");
+  }
+
+  // Offer to install Claude Code if missing
+  if (!hasClaude) {
+    const isRequired = !hasCodex;
+    log("Claude Code — Anthropic's AI coding assistant");
+    const installClaude = await askYN(rl, "Install Claude Code?", isRequired);
+    if (installClaude) {
+      const sp = spinner("Installing Claude Code...");
+      const result = run("npm install -g @anthropic-ai/claude-code 2>&1", { timeout: 120000 });
+      sp.stop(result !== null);
+      hasClaude = which("claude");
+      if (hasClaude) ok("Claude Code installed");
+      else warn("Install failed — try manually: npm install -g @anthropic-ai/claude-code");
+    }
+  }
+
+  // Offer to install Codex CLI if missing
+  if (!hasCodex) {
+    const isRequired = !hasClaude;
+    if (hasClaude) {
+      console.log("");
+      log("Tip: Installing Codex CLI too gives your team different AI perspectives.");
+    }
+    log("Codex CLI — OpenAI's AI coding assistant");
+    const installCodex = await askYN(rl, "Install Codex CLI?", isRequired);
+    if (installCodex) {
+      const sp = spinner("Installing Codex CLI...");
+      const result = run("npm install -g codex 2>&1", { timeout: 120000 });
+      sp.stop(result !== null);
+      hasCodex = which("codex");
+      if (hasCodex) ok("Codex CLI installed");
+      else warn("Install failed — try manually: npm install -g codex");
+    }
+  }
+
   if (!hasClaude && !hasCodex) {
-    fail("No AI CLI found — install Claude Code or Codex CLI");
+    fail("At least one AI CLI is required (Claude Code or Codex CLI).");
+    log("Install one and re-run: npx quadwork init");
     allOk = false;
   }
 
+  // ── CLI Authentication Checks ──
+  if (allOk) {
+    console.log("");
+    log("Checking CLI authentication...");
+    console.log("");
+
+    // GitHub CLI auth
+    const ghAuth = run("gh auth status 2>&1");
+    if (ghAuth && ghAuth.includes("Logged in")) {
+      ok("GitHub CLI — authenticated");
+    } else {
+      warn("GitHub CLI is installed but not logged in.");
+      log("  Run this command to log in:");
+      log("  → gh auth login");
+      log("");
+      const recheck = await askYN(rl, "Done? Press Y to re-check, or N to continue anyway", false);
+      if (recheck) {
+        const ghAuth2 = run("gh auth status 2>&1");
+        if (ghAuth2 && ghAuth2.includes("Logged in")) {
+          ok("GitHub CLI — authenticated");
+        } else {
+          warn("Still not authenticated — you can set this up later.");
+        }
+      }
+    }
+
+    // Claude Code auth
+    if (hasClaude) {
+      const claudeAuth = run("claude auth status 2>&1") || run("claude --version 2>&1");
+      if (claudeAuth && (claudeAuth.includes("authenticated") || claudeAuth.includes("Logged in") || claudeAuth.includes("@"))) {
+        ok("Claude Code — authenticated");
+      } else {
+        warn("Claude Code may need authentication.");
+        log("  If prompted when agents start, run: claude auth login");
+      }
+    }
+
+    // Codex CLI auth
+    if (hasCodex) {
+      const codexAuth = run("codex auth status 2>&1") || run("codex --version 2>&1");
+      if (codexAuth && (codexAuth.includes("authenticated") || codexAuth.includes("Logged in") || codexAuth.includes("@"))) {
+        ok("Codex CLI — authenticated");
+      } else {
+        warn("Codex CLI may need authentication.");
+        log("  If prompted when agents start, run: codex auth");
+      }
+    }
+  }
+
+  // ── Summary ──
+  console.log("");
+  if (allOk) {
+    ok("All prerequisites ready!");
+  } else {
+    console.log("");
+    log("Some prerequisites are missing. Fix the issues above and re-run:");
+    log("  → npx quadwork init");
+  }
+
   return allOk;
 }
 
@@ -223,31 +496,55 @@ async function setupGitHub(rl) {
 async function setupAgents(rl, repo) {
   header("Step 3: Agent Configuration");
 
-  // Prompt for CLI backend
+  // Detect available CLIs
   const hasClaude = which("claude");
   const hasCodex = which("codex");
+  const bothAvailable = hasClaude && hasCodex;
+  const onlyOneCli = (hasClaude && !hasCodex) || (!hasClaude && hasCodex);
   let defaultBackend = hasClaude ? "claude" : "codex";
-  log("Choose which AI CLI to run in agent terminals. Claude Code (`claude`) or OpenAI Codex (`codex`).");
-  const backend = await ask(rl, "Default CLI backend (claude/codex)", defaultBackend);
-  if (backend !== "claude" && backend !== "codex") {
-    fail("Backend must be 'claude' or 'codex'");
-    return null;
-  }
 
-  // Per-agent backend selection
   const backends = {};
-  const customPerAgent = await askYN(rl, "Use same backend for all agents?", true);
-  if (customPerAgent) {
-    for (const agent of AGENTS) backends[agent] = backend;
-  } else {
-    for (const agent of AGENTS) {
-      const agentBackend = await ask(rl, `${agent.toUpperCase()} backend (claude/codex)`, backend);
-      backends[agent] = (agentBackend === "claude" || agentBackend === "codex") ? agentBackend : backend;
+
+  if (onlyOneCli) {
+    // Single-CLI mode: default all agents, no prompt needed
+    const cliName = hasClaude ? "Claude Code" : "Codex CLI";
+    const otherName = hasClaude ? "Codex CLI" : "Claude Code";
+    const installCmd = hasClaude ? "npm install -g codex" : "npm install -g @anthropic-ai/claude-code";
+    ok(`${cliName} detected — all 4 agents will use ${cliName}.`);
+    console.log("");
+    log(`Tip: Installing ${otherName} too gives your team different AI perspectives,`);
+    log(`which can improve code review quality. You can add it anytime:`);
+    log(`  → ${installCmd}`);
+    console.log("");
+    for (const agent of AGENTS) backends[agent] = defaultBackend;
+  } else if (bothAvailable) {
+    log("Both Claude Code and Codex CLI are available.");
+    log("Choose which AI CLI to run in agent terminals.");
+    const backend = await ask(rl, "Default CLI backend (claude/codex)", defaultBackend);
+    if (backend !== "claude" && backend !== "codex") {
+      fail("Backend must be 'claude' or 'codex'");
+      return null;
     }
+    defaultBackend = backend;
+
+    // Per-agent backend selection
+    const customPerAgent = await askYN(rl, "Use same backend for all agents?", true);
+    if (customPerAgent) {
+      for (const agent of AGENTS) backends[agent] = backend;
+    } else {
+      for (const agent of AGENTS) {
+        const agentBackend = await ask(rl, `${agent.toUpperCase()} backend (claude/codex)`, backend);
+        backends[agent] = (agentBackend === "claude" || agentBackend === "codex") ? agentBackend : backend;
+      }
+    }
+  } else {
+    fail("No AI CLI found — install Claude Code or Codex CLI first.");
+    return null;
   }
+  const backend = defaultBackend;
 
   log("Path to your local clone of the repo. Four worktrees will be created next to it");
-  log("(e.g., project-t1/, project-t2a/, project-t2b/, project-t3/).");
+  log("(e.g., project-head/, project-reviewer1/, project-reviewer2/, project-dev/).");
   const projectDir = await ask(rl, "Project directory", process.cwd());
   const absDir = path.resolve(projectDir);
 
@@ -263,12 +560,12 @@ async function setupAgents(rl, repo) {
   }
 
   // Prompt for reviewer credentials (optional)
-  log("A separate reviewer account lets T2a/T2b approve PRs independently. You can set this up later in Settings.");
-  const wantReviewer = await askYN(rl, "Use a separate GitHub account for reviewers (T2a/T2b)?", false);
+  log("A separate reviewer account lets Reviewer1/Reviewer2 approve PRs independently. You can set this up later in Settings.");
+  const wantReviewer = await askYN(rl, "Use a separate GitHub account for reviewers (Reviewer1/Reviewer2)?", false);
   let reviewerUser = "";
   let reviewerTokenPath = "";
   if (wantReviewer) {
-    log("GitHub username for the reviewer account (used in T2a/T2b seed files for PR reviews).");
+    log("GitHub username for the reviewer account (used in Reviewer1/Reviewer2 seed files for PR reviews).");
     reviewerUser = await ask(rl, "Reviewer GitHub username", "");
     log("Path to a file containing a GitHub PAT for the reviewer account.");
     reviewerTokenPath = await ask(rl, "Reviewer token file path", path.join(os.homedir(), ".quadwork", "reviewer-token"));
@@ -342,7 +639,7 @@ function writeAgentChattrConfig(setup, configTomlPath, { skipInstall = false } =
 
   let tomlContent = fs.readFileSync(path.join(TEMPLATES_DIR, "config.toml"), "utf-8");
   for (const agent of AGENTS) {
-    tomlContent = tomlContent.replace(`{{${agent}_cwd}}`, setup.worktrees[agent]);
+    tomlContent = tomlContent.replace(new RegExp(`\\{\\{${agent}_cwd\\}\\}`, "g"), setup.worktrees[agent]);
   }
   // Replace placeholders
   tomlContent = tomlContent.replace(/\{\{project_name\}\}/g, setup.projectName);
@@ -356,6 +653,27 @@ function writeAgentChattrConfig(setup, configTomlPath, { skipInstall = false } =
     );
   }
 
+  // Per-project: isolated data dir and port
+  const dataDir = path.join(path.dirname(configTomlPath), "data");
+  if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
+  // Read assigned port from config (set by writeQuadWorkConfig)
+  const existingConfig = readConfig();
+  const existingProject = existingConfig.projects?.find((p) => p.id === setup.projectName);
+  const chattrPort = existingProject?.agentchattr_url
+    ? new URL(existingProject.agentchattr_url).port
+    : "8300";
+  const mcpHttp = existingProject?.mcp_http_port || 8200;
+  const mcpSse = existingProject?.mcp_sse_port || 8201;
+  tomlContent = tomlContent.replace(/^port = \d+/m, `port = ${chattrPort}`);
+  tomlContent = tomlContent.replace(/^data_dir = .+/m, `data_dir = "${dataDir}"`);
+  // Add session_token to [server] section if project has one
+  const sessionToken = existingProject?.agentchattr_token || "";
+  if (sessionToken) {
+    tomlContent = tomlContent.replace(/^(data_dir = .+)$/m, `$1\nsession_token = "${sessionToken}"`);
+  }
+  tomlContent = tomlContent.replace(/^http_port = \d+/m, `http_port = ${mcpHttp}`);
+  tomlContent = tomlContent.replace(/^sse_port = \d+/m, `sse_port = ${mcpSse}`);
+
   // Write config.toml
   const configDir = path.dirname(configTomlPath);
   if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
@@ -366,14 +684,14 @@ function writeAgentChattrConfig(setup, configTomlPath, { skipInstall = false } =
   let acAvailable = which("agentchattr");
   if (!acAvailable && !skipInstall) {
     const acSpinner = spinner("Installing AgentChattr...");
-    const installResult = run("pip install agentchattr 2>&1");
+    const installResult = run("pipx install agentchattr 2>&1");
     if (installResult !== null) {
       acSpinner.stop(true);
       acAvailable = which("agentchattr");
       if (!acAvailable) warn("agentchattr binary not found in PATH after install");
     } else {
       acSpinner.stop(false);
-      warn("Install manually: pip install agentchattr");
+      warn("Install manually: pipx install agentchattr");
     }
   }
 
@@ -390,8 +708,9 @@ function writeAgentChattrConfig(setup, configTomlPath, { skipInstall = false } =
     acProc.unref();
     if (acProc.pid) {
       ok(`AgentChattr started (PID: ${acProc.pid})`);
-      const pidFile = path.join(CONFIG_DIR, "agentchattr.pid");
+      // Per-project PID file
       if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      const pidFile = path.join(CONFIG_DIR, `agentchattr-${setup.projectName}.pid`);
       fs.writeFileSync(pidFile, String(acProc.pid));
     } else {
       warn("Could not start AgentChattr — start manually: agentchattr --config " + configTomlPath);
@@ -464,12 +783,17 @@ async function setupAddons(rl, setup, configTomlPath) {
           bridge_dir: telegramDir,
         };
 
+        // Resolve per-project AgentChattr URL
+        const projectCfg = readConfig();
+        const projectEntry = projectCfg.projects?.find((p) => p.id === setup.projectName);
+        const projectChattrUrl = projectEntry?.agentchattr_url || "http://127.0.0.1:8300";
+
         // Append telegram section to config.toml (token read from env at runtime)
         const telegramSection = `
 [telegram]
 bot_token = "env:${envKey}"
 chat_id = "${chatId}"
-agentchattr_url = "http://127.0.0.1:8300"
+agentchattr_url = "${projectChattrUrl}"
 poll_interval = 2
 bridge_sender = "telegram-bridge"
 `;
@@ -481,7 +805,7 @@ bridge_sender = "telegram-bridge"
         if (fs.existsSync(bridgeScript)) {
           log("Starting Telegram bridge...");
           const bridgeToml = path.join(CONFIG_DIR, `telegram-${setup.projectName}.toml`);
-          const bridgeTomlContent = `[telegram]\nbot_token = "${botToken}"\nchat_id = "${chatId}"\n\n[agentchattr]\nurl = "http://127.0.0.1:8300"\n`;
+          const bridgeTomlContent = `[telegram]\nbot_token = "${botToken}"\nchat_id = "${chatId}"\n\n[agentchattr]\nurl = "${projectChattrUrl}"\n`;
           fs.writeFileSync(bridgeToml, bridgeTomlContent, { mode: 0o600 });
           fs.chmodSync(bridgeToml, 0o600);
           const bridgeProc = spawn("python3", [bridgeScript, "--config", bridgeToml], {
@@ -586,9 +910,25 @@ function writeQuadWorkConfig(setup) {
     };
   }
 
+  // Auto-assign per-project AgentChattr and MCP ports (scan existing to avoid collisions)
+  const existingIdx = config.projects.findIndex((p) => p.id === setup.projectName);
+  const usedChattrPorts = new Set(config.projects.map((p) => {
+    try { return parseInt(new URL(p.agentchattr_url).port, 10); } catch { return 0; }
+  }).filter(Boolean));
+  const usedMcpPorts = new Set(config.projects.flatMap((p) => [p.mcp_http_port, p.mcp_sse_port]).filter(Boolean));
+  let chattrPort = 8300;
+  while (usedChattrPorts.has(chattrPort)) chattrPort++;
+  let mcp_http = 8200;
+  while (usedMcpPorts.has(mcp_http)) mcp_http++;
+  let mcp_sse = mcp_http + 1;
+  while (usedMcpPorts.has(mcp_sse)) mcp_sse++;
+  project.agentchattr_url = `http://127.0.0.1:${chattrPort}`;
+  project.agentchattr_token = require("crypto").randomBytes(16).toString("hex");
+  project.mcp_http_port = mcp_http;
+  project.mcp_sse_port = mcp_sse;
+
   // Upsert project
-  const idx = config.projects.findIndex((p) => p.id === setup.projectName);
-  if (idx >= 0) config.projects[idx] = project;
+  if (existingIdx >= 0) config.projects[existingIdx] = project;
   else config.projects.push(project);
 
   writeConfig(config);
@@ -601,53 +941,102 @@ async function cmdInit() {
   console.log("");
   console.log(`  ${c.cyan}${c.bold}╔══════════════════════════════════════════╗${c.reset}`);
   console.log(`  ${c.cyan}${c.bold}║${c.reset}  ${c.white}${c.bold}QuadWork Init${c.reset}                           ${c.cyan}${c.bold}║${c.reset}`);
-  console.log(`  ${c.cyan}${c.bold}║${c.reset}  ${c.dim}4-agent coding team setup${c.reset}                ${c.cyan}${c.bold}║${c.reset}`);
+  console.log(`  ${c.cyan}${c.bold}║${c.reset}  ${c.dim}Global setup — projects via web UI${c.reset}       ${c.cyan}${c.bold}║${c.reset}`);
   console.log(`  ${c.cyan}${c.bold}╚══════════════════════════════════════════╝${c.reset}`);
-  console.log(`\n  ${c.dim}Tip: Press Enter to accept defaults shown in [brackets].${c.reset}\n`);
+  console.log(`\n  ${c.dim}Press Enter to accept defaults. Takes under 30 seconds.${c.reset}\n`);
 
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
   try {
-    // Step 1: Prerequisites
-    const prereqsOk = checkPrereqs();
+    // Step 1: Prerequisites (header printed by checkPrereqs)
+    const prereqsOk = await checkPrereqs(rl);
     if (!prereqsOk) {
       const proceed = await askYN(rl, "Some prerequisites missing. Continue anyway?", false);
       if (!proceed) { rl.close(); process.exit(1); }
     }
 
-    // Step 2: GitHub
-    const repo = await setupGitHub(rl);
-    if (!repo) { rl.close(); process.exit(1); }
-
-    // Step 3: Agents
-    const setup = await setupAgents(rl, repo);
-    if (!setup) { rl.close(); process.exit(1); }
-
-    // Step 4: AgentChattr config (skip install if prereqs already flagged it missing)
-    const configTomlPath = path.join(setup.absDir, "config.toml");
-    writeAgentChattrConfig(setup, configTomlPath, { skipInstall: !agentChattrFound });
-
-    // Step 5: Optional add-ons
-    await setupAddons(rl, setup, configTomlPath);
-
-    // Write QuadWork config
-    writeQuadWorkConfig(setup);
+    // Step 2: Dashboard port
+    header("Step 2: Dashboard Port");
+    const port = await ask(rl, "Port for the QuadWork dashboard (Enter for default)", "8400");
+
+    // Write global config
+    const config = readConfig();
+    config.port = parseInt(port, 10) || 8400;
+    writeConfig(config);
+    ok(`Wrote ${CONFIG_PATH}`);
+
+    // Step 3: Start server
+    header("Step 3: Starting Dashboard");
+    const quadworkDir = path.join(__dirname, "..");
+    const serverDir = path.join(quadworkDir, "server");
+    let serverPid = null;
+    if (fs.existsSync(path.join(serverDir, "index.js"))) {
+      const server = spawn("node", [serverDir], {
+        stdio: "ignore",
+        detached: true,
+        env: { ...process.env },
+      });
+      server.unref();
+      if (server.pid) {
+        serverPid = server.pid;
+        ok(`Server started (PID: ${serverPid})`);
+        const pidFile = path.join(CONFIG_DIR, "server.pid");
+        if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(pidFile, String(serverPid));
+      }
+    } else {
+      warn("Server not found — run from the quadwork directory");
+    }
 
-    // Done
-    header("Setup Complete");
-    log(`Project:      ${setup.projectName}`);
-    log(`Repo:         ${setup.repo}`);
-    log(`Worktrees:    ${AGENTS.map((a) => `${setup.projectName}-${a}/`).join(", ")}`);
-    log(`Backends:     ${AGENTS.map((a) => `${a.toUpperCase()}=${(setup.backends && setup.backends[a]) || setup.backend}`).join(", ")}`);
-    log(`Config:       ${CONFIG_PATH}`);
-    log(`AgentChattr:  ${configTomlPath}`);
-    if (setup.telegram) log(`Telegram:     configured`);
-    if (setup.memoryDir) log(`Shared Memory: ${setup.memoryDir}`);
-    log("");
-    log("Next steps:");
-    log("  npx quadwork start    — launch dashboard + agents");
-    log("  npx quadwork stop     — stop all processes");
-    log("");
+    // Done — celebratory welcome
+    const dashPort = parseInt(port, 10) || 8400;
+    const dashboardUrl = `http://127.0.0.1:${dashPort}`;
+
+    console.log("");
+    console.log(`  ${c.cyan}${c.bold}╔══════════════════════════════════════════════════════════╗${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}                                                          ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}   ${c.green}${c.bold}Welcome to QuadWork!${c.reset}                                ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}                                                          ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}   Your AI-powered dev team is ready to ship.             ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}                                                          ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}   ${c.green}*${c.reset} ${c.bold}Head${c.reset}        ${c.dim}— coordinates & merges${c.reset}                  ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}   ${c.green}*${c.reset} ${c.bold}Dev${c.reset}         ${c.dim}— writes all the code${c.reset}                   ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}   ${c.green}*${c.reset} ${c.bold}Reviewer1${c.reset}   ${c.dim}— independent code review${c.reset}               ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}   ${c.green}*${c.reset} ${c.bold}Reviewer2${c.reset}   ${c.dim}— independent code review${c.reset}               ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}                                                          ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}   4 agents. Full GitHub workflow. Runs while you sleep.  ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}║${c.reset}                                                          ${c.cyan}${c.bold}║${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}╚══════════════════════════════════════════════════════════╝${c.reset}`);
+    console.log("");
+    if (serverPid) {
+      console.log(`  ${c.green}*${c.reset} Server running at ${c.cyan}${dashboardUrl}${c.reset} ${c.dim}(PID: ${serverPid})${c.reset}`);
+    } else {
+      console.log(`  ${c.yellow}*${c.reset} Server not started — run ${c.dim}npx quadwork start${c.reset} to launch`);
+    }
+    console.log(`  ${c.green}*${c.reset} Config saved to ${c.dim}${CONFIG_PATH}${c.reset}`);
+    console.log("");
+    console.log(`  ${c.cyan}${c.bold}--- Create Your First Project ---${c.reset}`);
+    console.log("");
+    console.log(`  Your browser is opening now. If not, visit:`);
+    console.log("");
+    console.log(`    ${c.cyan}${c.bold}${dashboardUrl}/setup${c.reset}`);
+    console.log("");
+    console.log(`    ${c.dim}1.${c.reset} Connect a GitHub repo`);
+    console.log(`    ${c.dim}2.${c.reset} Pick models for each agent`);
+    console.log(`    ${c.dim}3.${c.reset} Hit Start — your team takes it from there`);
+    console.log("");
+    console.log(`  ${c.dim}Commands:${c.reset}`);
+    console.log(`    ${c.dim}npx quadwork start${c.reset}    — restart everything`);
+    console.log(`    ${c.dim}npx quadwork stop${c.reset}     — shut it all down`);
+    console.log("");
+    console.log(`  ${c.green}${c.bold}Happy shipping!${c.reset}`);
+    console.log("");
+
+    // Open browser
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    setTimeout(() => {
+      try { execSync(`${openCmd} ${dashboardUrl}/setup`, { stdio: "ignore" }); } catch {}
+    }, 1500);
 
     rl.close();
   } catch (err) {
@@ -698,11 +1087,12 @@ function cmdStart() {
   const pidFile = path.join(CONFIG_DIR, "server.pid");
   fs.writeFileSync(pidFile, String(server.pid));
 
-  // Start AgentChattr if installed and config.toml exists for first project
-  const firstProject = config.projects[0];
-  if (firstProject && which("agentchattr")) {
-    const configToml = path.join(firstProject.working_dir, "config.toml");
-    if (fs.existsSync(configToml)) {
+  // Start AgentChattr for each project that has a config.toml
+  if (which("agentchattr")) {
+    for (const project of config.projects) {
+      if (!project.working_dir) continue;
+      const configToml = path.join(project.working_dir, "agentchattr", "config.toml");
+      if (!fs.existsSync(configToml)) continue;
       const acProc = spawn("agentchattr", ["--config", configToml], {
         stdio: "ignore",
         detached: true,
@@ -710,8 +1100,8 @@ function cmdStart() {
       acProc.on("error", () => {});
       acProc.unref();
       if (acProc.pid) {
-        ok(`AgentChattr started (PID: ${acProc.pid})`);
-        fs.writeFileSync(path.join(CONFIG_DIR, "agentchattr.pid"), String(acProc.pid));
+        ok(`AgentChattr started for ${project.id} (PID: ${acProc.pid})`);
+        fs.writeFileSync(path.join(CONFIG_DIR, `agentchattr-${project.id}.pid`), String(acProc.pid));
       }
     }
   }
@@ -750,9 +1140,30 @@ function cmdStop() {
 
   let stopped = 0;
   if (stopPid("Telegram bridge", "telegram-bridge.pid")) stopped++;
+
+  // Stop per-project AgentChattr instances
+  const config = readConfig();
+  for (const project of (config.projects || [])) {
+    if (stopPid(`AgentChattr (${project.id})`, `agentchattr-${project.id}.pid`)) stopped++;
+  }
+  // Also stop legacy single-instance PID if present
   if (stopPid("AgentChattr", "agentchattr.pid")) stopped++;
+
   if (stopPid("Server", "server.pid")) stopped++;
 
+  // Stop caffeinate via the running server's API (targets only QuadWork's instance)
+  if (process.platform === "darwin") {
+    const cfg = readConfig();
+    const qwPort = cfg.port || 8400;
+    try {
+      const result = run(`curl -s -X POST http://127.0.0.1:${qwPort}/api/caffeinate/stop 2>/dev/null`);
+      if (result && result.includes('"ok":true')) {
+        ok("Stopped caffeinate (sleep prevention)");
+        stopped++;
+      }
+    } catch {}
+  }
+
   if (stopped === 0) warn("No running processes found");
   else ok(`Stopped ${stopped} process(es)`);
   log("");
@@ -772,11 +1183,11 @@ async function cmdAddProject() {
     const setup = await setupAgents(rl, repo);
     if (!setup) { rl.close(); process.exit(1); }
 
-    const configTomlPath = path.join(setup.absDir, "config.toml");
-    writeAgentChattrConfig(setup, configTomlPath);
-
     writeQuadWorkConfig(setup);
 
+    const configTomlPath = path.join(setup.absDir, "agentchattr", "config.toml");
+    writeAgentChattrConfig(setup, configTomlPath);
+
     header("Project Added");
     log(`Project:      ${setup.projectName}`);
     log(`Repo:         ${setup.repo}`);
@@ -813,16 +1224,20 @@ switch (command) {
   Usage: quadwork <command>
 
   Commands:
-    init          Set up a new QuadWork 4-agent environment
+    init          Global setup (prereqs, port, backend) — then open web UI
     start         Start the QuadWork dashboard and backend
     stop          Stop all QuadWork processes
-    add-project   Add a project to an existing QuadWork setup
+    add-project   Add a project via CLI (alternative to web UI /setup)
+
+  Workflow:
+    1. npx quadwork init     — one-time global setup, opens dashboard
+    2. Open /setup in browser — create projects with guided web UI
+    3. npx quadwork stop     — stop everything when done
 
   Examples:
     npx quadwork init
     npx quadwork start
     npx quadwork stop
-    npx quadwork add-project
 `);
     if (command) process.exit(1);
 }