quadwork 0.1.1 → 0.1.3

package/README.md

@@ -84,10 +84,10 @@ Config is stored at `~/.quadwork/config.json`:
       "repo": "owner/repo",
       "working_dir": "/path/to/project",
       "agents": {
-        "t1": { "cwd": "/path/to/project-t1", "command": "claude" },
-        "t2a": { "cwd": "/path/to/project-t2a", "command": "claude" },
-        "t2b": { "cwd": "/path/to/project-t2b", "command": "claude" },
-        "t3": { "cwd": "/path/to/project-t3", "command": "claude" }
+        "head": { "cwd": "/path/to/project-head", "command": "claude" },
+        "reviewer1": { "cwd": "/path/to/project-reviewer1", "command": "claude" },
+        "reviewer2": { "cwd": "/path/to/project-reviewer2", "command": "claude" },
+        "dev": { "cwd": "/path/to/project-dev", "command": "claude" }
       }
     }
   ]

package/bin/quadwork.js

@@ -11,15 +11,45 @@ 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"];
-
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function log(msg) { console.log(`  ${msg}`); }
-function ok(msg) { console.log(`  ✓ ${msg}`); }
-function warn(msg) { console.log(`  ⚠ ${msg}`); }
-function fail(msg) { console.error(`  ✗ ${msg}`); }
-function header(msg) { console.log(`\n── ${msg} ${"─".repeat(Math.max(0, 58 - msg.length))}\n`); }
+const AGENTS = ["head", "reviewer1", "reviewer2", "dev"];
+
+// ─── ANSI Helpers ──────────────────────────────────────────────────────────
+
+const isTTY = process.stdout.isTTY;
+const c = isTTY ? {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+} : { reset: "", bold: "", dim: "", green: "", yellow: "", red: "", cyan: "", white: "" };
+
+function log(msg) { console.log(`  ${c.dim}${msg}${c.reset}`); }
+function ok(msg) { console.log(`  ${c.green}✓${c.reset} ${msg}`); }
+function warn(msg) { console.log(`  ${c.yellow}⚠ ${msg}${c.reset}`); }
+function fail(msg) { console.error(`  ${c.red}✗ ${msg}${c.reset}`); }
+function header(msg) { console.log(`\n  ${c.cyan}${c.bold}┌─ ${msg} ${"─".repeat(Math.max(0, 54 - msg.length))}┐${c.reset}\n`); }
+
+function spinner(msg) {
+  if (!isTTY) {
+    console.log(`  ${msg}`);
+    return { stop(result) { console.log(`  ${result ? "✓" : "✗"} ${msg}`); } };
+  }
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  const id = setInterval(() => {
+    process.stdout.write(`\r  ${c.cyan}${frames[i++ % frames.length]}${c.reset} ${msg}`);
+  }, 80);
+  return {
+    stop(result) {
+      clearInterval(id);
+      process.stdout.write(`\r  ${result ? `${c.green}✓${c.reset} ${msg}` : `${c.red}✗${c.reset} ${msg}`}${" ".repeat(10)}\n`);
+    },
+  };
+}
 
 function run(cmd, opts = {}) {
   try {
@@ -35,26 +65,91 @@ function which(cmd) {
 
 function ask(rl, question, defaultVal) {
   return new Promise((resolve) => {
-    const suffix = defaultVal ? ` (${defaultVal})` : "";
-    rl.question(`  ${question}${suffix}: `, (answer) => {
+    const suffix = defaultVal ? ` ${c.dim}[${defaultVal}]${c.reset}` : "";
+    rl.question(`  ${c.bold}${question}${c.reset}${suffix}${c.cyan} > ${c.reset}`, (answer) => {
       resolve(answer.trim() || defaultVal || "");
     });
   });
 }
 
+function askSecret(rl, question) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(`  ${c.bold}${question}${c.reset}${c.cyan} > ${c.reset}`);
+    let secret = "";
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onData = (ch) => {
+      // Iterate per character to handle pasted multi-char input
+      const str = ch.toString("utf-8");
+      for (const c of str) {
+        if (c === "\n" || c === "\r") {
+          stdin.setRawMode(wasRaw || false);
+          stdin.removeListener("data", onData);
+          stdout.write("\n");
+          resolve(secret);
+          return;
+        } else if (c === "\u007F" || c === "\b") {
+          if (secret.length > 0) {
+            secret = secret.slice(0, -1);
+            stdout.write("\b \b");
+          }
+        } else if (c === "\u0003") {
+          process.exit(1);
+        } else if (c >= " ") {
+          secret += c;
+          stdout.write("*");
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+function maskValue(val) {
+  if (!val || val.length < 8) return "****";
+  return val.slice(0, 4) + "***" + val.slice(-3);
+}
+
 function askYN(rl, question, defaultYes = false) {
   return new Promise((resolve) => {
     const hint = defaultYes ? "Y/n" : "y/N";
-    rl.question(`  ${question} [${hint}]: `, (answer) => {
+    rl.question(`  ${c.bold}${question}${c.reset} ${c.dim}[${hint}]${c.reset}${c.cyan} > ${c.reset}`, (answer) => {
       const a = answer.trim().toLowerCase();
       resolve(a === "" ? defaultYes : a === "y" || a === "yes");
     });
   });
 }
 
+// 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: [] };
   }
@@ -67,6 +162,8 @@ function writeConfig(config) {
 
 // ─── Prerequisites ──────────────────────────────────────────────────────────
 
+let agentChattrFound = false;
+
 function checkPrereqs() {
   header("Step 1: Prerequisites");
   let allOk = true;
@@ -90,7 +187,7 @@ function checkPrereqs() {
 
   // AgentChattr
   const acVer = run("agentchattr --version") || run("python3 -m agentchattr --version");
-  if (acVer) ok(`AgentChattr ${acVer}`);
+  if (acVer) { ok(`AgentChattr ${acVer}`); agentChattrFound = true; }
   else { warn("AgentChattr not found — install: pip install agentchattr"); allOk = false; }
 
   // gh CLI
@@ -132,10 +229,12 @@ async function setupGitHub(rl) {
   }
 
   // Verify repo exists
+  const sp = spinner(`Verifying ${repo}...`);
   const repoCheck = run(`gh repo view ${repo} --json name 2>&1`);
   if (repoCheck && repoCheck.includes('"name"')) {
-    ok(`Repo ${repo} verified`);
+    sp.stop(true);
   } else {
+    sp.stop(false);
     fail(`Cannot access ${repo} — check permissions`);
     return null;
   }
@@ -171,7 +270,8 @@ async function setupAgents(rl, repo) {
     }
   }
 
-  log("Path to your local clone of the repo. Worktrees will be created as sibling directories.");
+  log("Path to your local clone of the repo. Four worktrees will be created next to it");
+  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);
 
@@ -187,12 +287,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"));
@@ -200,25 +300,19 @@ async function setupAgents(rl, repo) {
 
   const projectName = path.basename(absDir);
   log(`Project: ${projectName}`);
-  log("Creating worktrees for 4 agents...\n");
+  const wtSpinner = spinner("Creating worktrees and seeding files...");
 
   const worktrees = {};
+  let wtFailed = null;
   for (const agent of AGENTS) {
     const wtDir = path.join(path.dirname(absDir), `${projectName}-${agent}`);
-    if (fs.existsSync(wtDir)) {
-      ok(`Worktree exists: ${agent} → ${wtDir}`);
-    } else {
+    if (!fs.existsSync(wtDir)) {
       const branchName = `worktree-${agent}`;
-      // Create branch if needed
       run(`git -C "${absDir}" branch ${branchName} HEAD 2>&1`);
       const result = run(`git -C "${absDir}" worktree add "${wtDir}" ${branchName} 2>&1`);
-      if (result !== null) {
-        ok(`Created worktree: ${agent} → ${wtDir}`);
-      } else {
-        // Try without branch (detached)
+      if (!result) {
         const result2 = run(`git -C "${absDir}" worktree add --detach "${wtDir}" HEAD 2>&1`);
-        if (result2 !== null) ok(`Created worktree (detached): ${agent} → ${wtDir}`);
-        else { fail(`Failed to create worktree for ${agent}`); return null; }
+        if (!result2) { wtFailed = agent; break; }
       }
     }
     worktrees[agent] = wtDir;
@@ -238,10 +332,15 @@ async function setupAgents(rl, repo) {
         seedContent = seedContent.replace(/\{\{reviewer_token_path\}\}/g, "");
       }
       fs.writeFileSync(seedDst, seedContent);
-      log(`  Copied ${agent}.AGENTS.md`);
     }
   }
 
+  if (wtFailed) {
+    wtSpinner.stop(false);
+    fail(`Failed to create worktree for ${wtFailed}`);
+    return null;
+  }
+
   // Copy CLAUDE.md to each worktree
   const claudeSrc = path.join(TEMPLATES_DIR, "CLAUDE.md");
   if (fs.existsSync(claudeSrc)) {
@@ -249,25 +348,25 @@ async function setupAgents(rl, repo) {
     claudeContent = claudeContent.replace(/\{\{project_name\}\}/g, projectName);
     for (const agent of AGENTS) {
       const dst = path.join(worktrees[agent], "CLAUDE.md");
-      // Don't overwrite if CLAUDE.md already exists
       if (!fs.existsSync(dst)) {
         fs.writeFileSync(dst, claudeContent);
       }
     }
-    ok("Copied CLAUDE.md to all worktrees");
   }
 
+  wtSpinner.stop(true);
+
   return { projectName, absDir, worktrees, repo, backend, backends };
 }
 
 // ─── AgentChattr Config ─────────────────────────────────────────────────────
 
-function writeAgentChattrConfig(setup, configTomlPath) {
+function writeAgentChattrConfig(setup, configTomlPath, { skipInstall = false } = {}) {
   header("Step 4: AgentChattr Setup");
 
   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);
@@ -281,25 +380,45 @@ function writeAgentChattrConfig(setup, configTomlPath) {
     );
   }
 
+  // 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 });
   fs.writeFileSync(configTomlPath, tomlContent);
   ok(`Wrote ${configTomlPath}`);
 
-  // Install AgentChattr if missing, then start it
-  // Only check for the actual binary — python3 -m availability doesn't mean the CLI is in PATH
+  // Start AgentChattr if available; optionally skip install attempt
   let acAvailable = which("agentchattr");
-  if (!acAvailable) {
-    log("Installing AgentChattr...");
+  if (!acAvailable && !skipInstall) {
+    const acSpinner = spinner("Installing AgentChattr...");
     const installResult = run("pip install agentchattr 2>&1");
     if (installResult !== null) {
-      ok("Installed AgentChattr");
-      // Re-check that the binary is actually in PATH after install
+      acSpinner.stop(true);
       acAvailable = which("agentchattr");
       if (!acAvailable) warn("agentchattr binary not found in PATH after install");
     } else {
-      warn("Failed to install AgentChattr — install manually: pip install agentchattr");
+      acSpinner.stop(false);
+      warn("Install manually: pip install agentchattr");
     }
   }
 
@@ -316,8 +435,9 @@ function writeAgentChattrConfig(setup, configTomlPath) {
     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);
@@ -340,10 +460,10 @@ async function setupAddons(rl, setup, configTomlPath) {
   if (wantTelegram) {
     const telegramDir = path.join(path.dirname(setup.absDir), "agentchattr-telegram");
     if (!fs.existsSync(telegramDir)) {
-      log("Cloning agentchattr-telegram...");
+      const cloneSpinner = spinner("Cloning agentchattr-telegram...");
       const cloneResult = run(`git clone https://github.com/realproject7/agentchattr-telegram.git "${telegramDir}" 2>&1`);
-      if (cloneResult !== null) ok("Cloned agentchattr-telegram");
-      else warn("Failed to clone — you can set it up manually later");
+      cloneSpinner.stop(cloneResult !== null);
+      if (!cloneResult) warn("You can set it up manually later");
     } else {
       ok("agentchattr-telegram already present");
     }
@@ -351,12 +471,20 @@ async function setupAddons(rl, setup, configTomlPath) {
     if (fs.existsSync(telegramDir)) {
       const reqFile = path.join(telegramDir, "requirements.txt");
       if (fs.existsSync(reqFile)) {
-        run(`pip install -r "${reqFile}" 2>&1`);
-        ok("Installed Telegram Bridge dependencies");
+        const tgSpinner = spinner("Installing Telegram Bridge dependencies...");
+        const tgResult = run(`pip install -r "${reqFile}" 2>&1`);
+        tgSpinner.stop(tgResult !== null);
       }
 
-      const botToken = await ask(rl, "Telegram bot token", "");
+      log("Create a bot via @BotFather on Telegram (https://t.me/BotFather), then copy the token.");
+      const botToken = await askSecret(rl, "Telegram bot token");
+      log("To find your chat ID:");
+      log("  1. Open your bot on Telegram and send it any message (e.g., 'hi')");
+      log("  2. Run: curl https://api.telegram.org/bot<TOKEN>/getUpdates");
+      log("  3. Look for \"chat\":{\"id\":123456789,...} — the number is your chat ID");
+      log("  Note: Returns empty if no messages have been sent to the bot yet.");
       const chatId = await ask(rl, "Telegram chat ID", "");
+      log("Need help? See https://github.com/realproject7/agentchattr-telegram#readme");
 
       if (botToken && chatId) {
         // Write bot token to ~/.quadwork/.env (never stored in config files)
@@ -373,7 +501,7 @@ async function setupAddons(rl, setup, configTomlPath) {
         }
         fs.writeFileSync(envPath, envContent, { mode: 0o600 });
         fs.chmodSync(envPath, 0o600);
-        ok(`Saved bot token to ${envPath}`);
+        ok(`Saved bot token (${maskValue(botToken)}) to ${envPath}`);
 
         // Persist telegram settings for writeQuadWorkConfig (env reference, not plaintext)
         setup.telegram = {
@@ -382,12 +510,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"
 `;
@@ -399,7 +532,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], {
@@ -425,10 +558,10 @@ bridge_sender = "telegram-bridge"
   if (wantMemory) {
     const memoryDir = path.join(path.dirname(setup.absDir), "agent-memory");
     if (!fs.existsSync(memoryDir)) {
-      log("Cloning agent-memory...");
+      const memSpinner = spinner("Cloning agent-memory...");
       const cloneResult = run(`git clone https://github.com/realproject7/agent-memory.git "${memoryDir}" 2>&1`);
-      if (cloneResult !== null) ok("Cloned agent-memory");
-      else warn("Failed to clone — you can set it up manually later");
+      memSpinner.stop(cloneResult !== null);
+      if (!cloneResult) warn("You can set it up manually later");
     } else {
       ok("agent-memory already present");
     }
@@ -504,9 +637,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);
@@ -516,49 +665,78 @@ function writeQuadWorkConfig(setup) {
 // ─── Init Command ───────────────────────────────────────────────────────────
 
 async function cmdInit() {
-  console.log("\n  QuadWork Init — 4-agent coding team setup\n");
+  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}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`);
 
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
   try {
     // Step 1: Prerequisites
+    header("Step 1: Prerequisites");
     const prereqsOk = checkPrereqs();
     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
-    const configTomlPath = path.join(setup.absDir, "config.toml");
-    writeAgentChattrConfig(setup, configTomlPath);
-
-    // Step 5: Optional add-ons
-    await setupAddons(rl, setup, configTomlPath);
-
-    // Write QuadWork config
-    writeQuadWorkConfig(setup);
+    // Step 2: Global config
+    header("Step 2: Global Configuration");
+    const port = await ask(rl, "Dashboard port", "8400");
+    const defaultBackend = which("claude") ? "claude" : which("codex") ? "codex" : "claude";
+    const backend = await ask(rl, "Default CLI backend (claude/codex)", defaultBackend);
+
+    // Write global config
+    const config = readConfig();
+    config.port = parseInt(port, 10) || 8400;
+    config.default_backend = backend;
+    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");
+    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) {
+        ok(`Server started (PID: ${server.pid})`);
+        const pidFile = path.join(CONFIG_DIR, "server.pid");
+        if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(pidFile, String(server.pid));
+      }
+    } else {
+      warn("Server not found — run from the quadwork directory");
+    }
 
     // Done
+    const dashPort = parseInt(port, 10) || 8400;
+    const dashboardUrl = `http://127.0.0.1:${dashPort}`;
+
     header("Setup Complete");
-    log(`Project:      ${setup.projectName}`);
-    log(`Repo:         ${setup.repo}`);
-    log(`Worktrees:    ${AGENTS.map((a) => `${a}/`).join(", ")}`);
-    log(`Config:       ${CONFIG_PATH}`);
-    log(`AgentChattr:  ${configTomlPath}`);
+    log(`Config:     ${CONFIG_PATH}`);
+    log(`Dashboard:  ${dashboardUrl}`);
+    log(`Backend:    ${backend}`);
     log("");
     log("Next steps:");
-    log("  npx quadwork start    — launch dashboard + agents");
+    log(`  Open ${c.cyan}${dashboardUrl}/setup${c.reset} to create your first project`);
     log("  npx quadwork stop     — stop all processes");
     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) {
     fail(err.message);
@@ -608,11 +786,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,
@@ -620,8 +799,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));
       }
     }
   }
@@ -660,7 +839,15 @@ 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++;
 
   if (stopped === 0) warn("No running processes found");
@@ -682,11 +869,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}`);
@@ -723,16 +910,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);
 }