quadwork 1.0.16 → 1.1.0

package/server/index.js

@@ -131,22 +131,197 @@ const agentSessions = new Map();
 // AgentChattr server processes — per-project (key = projectId)
 const chattrProcesses = new Map();
 
+// --- MCP auth proxy for Codex (can't pass headers via -c flag) ---
+// Maps "project/agent" → { server, port }
+const mcpProxies = new Map();
+
+/**
+ * Start a local HTTP proxy that forwards MCP requests with Bearer token.
+ * Returns a Promise that resolves to the proxy URL once listening.
+ */
+function startMcpProxy(projectId, agentId, upstreamUrl, token) {
+  const key = `${projectId}/${agentId}`;
+  const existing = mcpProxies.get(key);
+  if (existing) return Promise.resolve(`http://127.0.0.1:${existing.port}/mcp`);
+
+  return new Promise((resolve, reject) => {
+    const proxyServer = http.createServer((req, res) => {
+      const parsedUrl = new URL(req.url, `http://127.0.0.1`);
+      const targetUrl = `${upstreamUrl}${parsedUrl.pathname}${parsedUrl.search}`;
+      const headers = { ...req.headers, host: new URL(upstreamUrl).host };
+      if (token) {
+        headers["authorization"] = `Bearer ${token}`;
+        headers["x-agent-token"] = token;
+      }
+      delete headers["content-length"];
+
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => {
+        const body = Buffer.concat(chunks);
+        const proxyReq = (upstreamUrl.startsWith("https") ? require("https") : http).request(
+          targetUrl,
+          { method: req.method, headers: { ...headers, "content-length": body.length } },
+          (proxyRes) => {
+            res.writeHead(proxyRes.statusCode, proxyRes.headers);
+            proxyRes.pipe(res);
+          }
+        );
+        proxyReq.on("error", (err) => {
+          res.writeHead(502);
+          res.end(`Proxy error: ${err.message}`);
+        });
+        proxyReq.end(body);
+      });
+    });
+
+    proxyServer.on("error", (err) => reject(err));
+    proxyServer.listen(0, "127.0.0.1", () => {
+      const port = proxyServer.address().port;
+      mcpProxies.set(key, { server: proxyServer, port });
+      resolve(`http://127.0.0.1:${port}/mcp`);
+    });
+  });
+}
+
+function stopMcpProxy(projectId, agentId) {
+  const key = `${projectId}/${agentId}`;
+  const proxy = mcpProxies.get(key);
+  if (proxy) {
+    try { proxy.server.close(); } catch {}
+    mcpProxies.delete(key);
+  }
+}
+
+// --- Permission bypass flags per CLI ---
+const PERMISSION_FLAGS = {
+  claude: ["--dangerously-skip-permissions"],
+  codex: ["--dangerously-bypass-approvals-and-sandbox"],
+  gemini: ["--yolo"],
+};
+
+// --- MCP config generation & agent launch args ---
+
+/**
+ * Generate a per-agent MCP config file for Claude (--mcp-config).
+ * Returns the absolute path to the written JSON file.
+ */
+function writeMcpConfigFile(projectId, agentId, mcpHttpPort, token) {
+  const os = require("os");
+  const configDir = path.join(os.homedir(), ".quadwork", projectId);
+  if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
+  const filePath = path.join(configDir, `mcp-${agentId}.json`);
+  const url = `http://127.0.0.1:${mcpHttpPort}/mcp`;
+  const config = {
+    mcpServers: {
+      agentchattr: {
+        type: "http",
+        url,
+        ...(token ? { headers: { Authorization: `Bearer ${token}` } } : {}),
+      },
+    },
+  };
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+  return filePath;
+}
+
+/**
+ * Build extra launch args for an agent (permission flags + MCP injection).
+ * Async because Codex proxy_flag mode needs to await proxy startup.
+ */
+async function buildAgentArgs(projectId, agentId) {
+  const cfg = readConfig();
+  const project = cfg.projects?.find((p) => p.id === projectId);
+  if (!project) return [];
+
+  const agentCfg = project.agents?.[agentId] || {};
+  const command = agentCfg.command || "claude";
+  const cliBase = command.split("/").pop().split(" ")[0]; // extract base CLI name
+  const args = [];
+
+  // Permission bypass flags
+  if (agentCfg.auto_approve !== false) {
+    const flags = PERMISSION_FLAGS[cliBase];
+    if (flags) args.push(...flags);
+  }
+
+  // MCP config injection
+  const mcpHttpPort = project.mcp_http_port;
+  const token = project.agentchattr_token;
+  if (mcpHttpPort) {
+    const injectMode = agentCfg.mcp_inject || (cliBase === "codex" ? "proxy_flag" : cliBase === "gemini" ? "env" : "flag");
+    if (injectMode === "flag") {
+      // Claude/Kimi: write config file, pass --mcp-config
+      const mcpConfigPath = writeMcpConfigFile(projectId, agentId, mcpHttpPort, token);
+      const flag = agentCfg.mcp_flag || "--mcp-config";
+      args.push(flag, mcpConfigPath);
+    } else if (injectMode === "proxy_flag") {
+      // Codex: start local auth proxy, pass proxy URL via -c flag
+      const upstreamUrl = `http://127.0.0.1:${mcpHttpPort}`;
+      const proxyUrl = await startMcpProxy(projectId, agentId, upstreamUrl, token);
+      if (proxyUrl) {
+        args.push("-c", `mcp_servers.agentchattr.url="${proxyUrl}"`);
+      }
+    }
+  }
+
+  return args;
+}
+
+/**
+ * Build extra env vars for an agent (MCP injection via env for Gemini).
+ */
+function buildAgentEnv(projectId, agentId) {
+  const cfg = readConfig();
+  const project = cfg.projects?.find((p) => p.id === projectId);
+  if (!project) return {};
+
+  const agentCfg = project.agents?.[agentId] || {};
+  const command = agentCfg.command || "claude";
+  const cliBase = command.split("/").pop().split(" ")[0];
+  const env = {};
+
+  // Gemini: inject MCP via env var
+  if (cliBase === "gemini" && project.mcp_http_port) {
+    const os = require("os");
+    const configDir = path.join(os.homedir(), ".quadwork", projectId);
+    if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
+    const settingsPath = path.join(configDir, `mcp-${agentId}-settings.json`);
+    const url = `http://127.0.0.1:${project.mcp_http_port}/mcp`;
+    const settings = {
+      mcpServers: {
+        agentchattr: {
+          type: "http",
+          url,
+          ...(project.agentchattr_token ? { headers: { Authorization: `Bearer ${project.agentchattr_token}` } } : {}),
+        },
+      },
+    };
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    env.GEMINI_CLI_SYSTEM_SETTINGS_PATH = settingsPath;
+  }
+
+  return env;
+}
+
 // Helper: spawn a PTY for a project/agent and register in agentSessions
-function spawnAgentPty(project, agent) {
+async function spawnAgentPty(project, agent) {
   const key = `${project}/${agent}`;
 
   const cwd = resolveAgentCwd(project, agent);
   if (!cwd) return { ok: false, error: `Unknown agent: ${key}` };
 
   const command = resolveAgentCommand(project, agent) || (process.env.SHELL || "/bin/zsh");
+  const args = await buildAgentArgs(project, agent);
+  const extraEnv = buildAgentEnv(project, agent);
 
   try {
-    const term = pty.spawn(command, [], {
+    const term = pty.spawn(command, args, {
       name: "xterm-256color",
       cols: 120,
       rows: 30,
       cwd,
-      env: process.env,
+      env: { ...process.env, ...extraEnv },
     });
 
     const session = { projectId: project, agentId: agent, term, ws: null, state: "running", error: null };
@@ -190,6 +365,9 @@ function stopAgentSession(key) {
   session.ws = null;
   session.state = "stopped";
   session.error = null;
+  // Clean up MCP auth proxy if running
+  const [projectId, agentId] = key.split("/");
+  if (projectId && agentId) stopMcpProxy(projectId, agentId);
 }
 
 app.get("/api/agents", (_req, res) => {
@@ -220,12 +398,21 @@ async function handleAgentChattr(req, res) {
   const { url: chattrUrl } = resolveProjectChattr(projectId);
   const chattrPort = new URL(chattrUrl).port || "8300";
 
-  // Find per-project config.toml (prefer project working_dir/agentchattr/config.toml)
+  // Find per-project config.toml. Phase 2E / #181: prefer the
+  // per-project AgentChattr clone ROOT (where the web/CLI wizards now
+  // write it as of #184/#185 — and where run.py actually reads it from).
+  // Fall back to the legacy <working_dir>/agentchattr/config.toml for
+  // v1 setups that haven't been migrated yet (#188).
   const cfg = readConfig();
   const project = cfg.projects?.find((p) => p.id === projectId);
-  const projectConfigToml = project?.working_dir
-    ? path.join(project.working_dir, "agentchattr", "config.toml")
-    : null;
+  const { dir: resolvedAcDir } = resolveProjectChattr(projectId);
+  let projectConfigToml = null;
+  if (resolvedAcDir && fs.existsSync(path.join(resolvedAcDir, "config.toml"))) {
+    projectConfigToml = path.join(resolvedAcDir, "config.toml");
+  } else if (project?.working_dir) {
+    const legacyToml = path.join(project.working_dir, "agentchattr", "config.toml");
+    if (fs.existsSync(legacyToml)) projectConfigToml = legacyToml;
+  }
 
   function getProc() {
     return chattrProcesses.get(projectId) || { process: null, state: "stopped", error: null };
@@ -423,7 +610,7 @@ app.post("/api/agents/:project/reset", async (req, res) => {
 
 // --- Lifecycle: start spawns PTY (visible in terminal panel) ---
 
-app.post("/api/agents/:project/:agent/start", (req, res) => {
+app.post("/api/agents/:project/:agent/start", async (req, res) => {
   const { project, agent } = req.params;
   const key = `${project}/${agent}`;
 
@@ -432,7 +619,7 @@ app.post("/api/agents/:project/:agent/start", (req, res) => {
     return res.json({ ok: true, state: "running", message: "Already running" });
   }
 
-  const result = spawnAgentPty(project, agent);
+  const result = await spawnAgentPty(project, agent);
   if (result.ok) {
     res.json({ ok: true, state: "running", pid: result.pid });
   } else {
@@ -451,14 +638,14 @@ app.post("/api/agents/:project/:agent/stop", (req, res) => {
 
 // --- Lifecycle: restart ---
 
-app.post("/api/agents/:project/:agent/restart", (req, res) => {
+app.post("/api/agents/:project/:agent/restart", async (req, res) => {
   const { project, agent } = req.params;
   const key = `${project}/${agent}`;
 
   stopAgentSession(key);
 
-  setTimeout(() => {
-    const result = spawnAgentPty(project, agent);
+  setTimeout(async () => {
+    const result = await spawnAgentPty(project, agent);
     if (result.ok) {
       res.json({ ok: true, state: "running", pid: result.pid });
     } else {
@@ -708,7 +895,7 @@ app.use((req, res, next) => {
 
 const wss = new WebSocketServer({ server, path: "/ws/terminal" });
 
-wss.on("connection", (ws, req) => {
+wss.on("connection", async (ws, req) => {
   const params = new URL(req.url, `http://localhost:${PORT}`).searchParams;
   const projectId = params.get("project");
   const agentId = params.get("agent");
@@ -723,7 +910,7 @@ wss.on("connection", (ws, req) => {
 
   // If no active PTY, spawn one
   if (!session || !session.term) {
-    const result = spawnAgentPty(projectId, agentId);
+    const result = await spawnAgentPty(projectId, agentId);
     if (!result.ok) {
       ws.close(1011, "pty-spawn-failed");
       return;

package/server/install-agentchattr.js

@@ -0,0 +1,215 @@
+// Shared AgentChattr install helper used by both the CLI wizard
+// (bin/quadwork.js) and the web setup route (server/routes.js).
+//
+// Extracted as part of #185 (Phase 2D of master #181) so the web UI
+// can clone AgentChattr per-project without duplicating the locking,
+// idempotency, and cleanup-safety logic that #183 + #187 added.
+//
+// Public API:
+//   findAgentChattr(dir)               → string|null
+//   installAgentChattr(dir)            → string|null  (.lastError on failure)
+//   chattrSpawnArgs(dir, extraArgs)    → { command, spawnArgs, cwd } | null
+//   AGENTCHATTR_REPO                   → upstream URL constant
+//
+// Self-contained — depends only on Node built-ins so it's safe to require
+// from anywhere in the project (CLI bin, server routes, future tests).
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const AGENTCHATTR_REPO = "https://github.com/bcurts/agentchattr.git";
+
+// Stale-lock thresholds for installAgentChattr().
+// Lock files older than this OR whose owning pid is no longer alive are
+// treated as crashed and reclaimed. Tuned to comfortably exceed the longest
+// step (pip install of agentchattr requirements, ~120s timeout).
+const INSTALL_LOCK_STALE_MS = 10 * 60 * 1000; // 10 min
+const INSTALL_LOCK_WAIT_TOTAL_MS = 30 * 1000;  // wait up to 30s for a peer
+const INSTALL_LOCK_POLL_MS = 500;
+
+function _run(cmd, opts = {}) {
+  try { return execSync(cmd, { encoding: "utf-8", stdio: "pipe", ...opts }).trim(); }
+  catch { return null; }
+}
+
+function _isPidAlive(pid) {
+  if (!pid || !Number.isFinite(pid)) return false;
+  try { process.kill(pid, 0); return true; }
+  catch (e) { return e.code === "EPERM"; }
+}
+
+function _readLock(lockFile) {
+  try {
+    const raw = fs.readFileSync(lockFile, "utf-8").trim();
+    const [pidStr, tsStr] = raw.split(":");
+    return { pid: parseInt(pidStr, 10), ts: parseInt(tsStr, 10) || 0 };
+  } catch { return null; }
+}
+
+function _isLockStale(lockFile) {
+  const info = _readLock(lockFile);
+  if (!info) return true;
+  if (Date.now() - info.ts > INSTALL_LOCK_STALE_MS) return true;
+  if (!_isPidAlive(info.pid)) return true;
+  return false;
+}
+
+/**
+ * Check if AgentChattr is fully installed (cloned + venv ready) at `dir`.
+ * Returns the directory path if both run.py and .venv/bin/python exist, or null.
+ * Caller must pass an explicit `dir` — there is no default.
+ */
+function findAgentChattr(dir) {
+  if (!dir) return null;
+  if (fs.existsSync(path.join(dir, "run.py")) && fs.existsSync(path.join(dir, ".venv", "bin", "python"))) return dir;
+  return null;
+}
+
+/**
+ * Clone AgentChattr and set up its venv at `dir`. Idempotent — safe to
+ * re-run on the same path, and safe to call repeatedly with different
+ * paths in the same process. Designed to support per-project clones (#181).
+ *
+ * Behavior on re-run:
+ *   - Fully-installed path → no-op (skips clone, skips venv create, skips pip)
+ *   - Missing run.py        → clones (only after refusing to overwrite
+ *                             unrelated content; see safety rules below)
+ *   - Missing venv          → creates venv and reinstalls requirements
+ *
+ * Safety rules — never accidentally clean up unrelated directories:
+ *   - Empty dir                                  → safe to remove
+ *   - Git repo whose origin contains "agentchattr" → safe to remove
+ *   - Anything else                              → refuse, return null
+ *
+ * Concurrency: a per-target lock at `${dir}.install.lock` serializes
+ * concurrent installs to the same path. Stale locks (dead pid OR older
+ * than 10 min) are reclaimed atomically via rename → unlink. Live
+ * peers are polled for up to 30s; after that, returns null with a
+ * clear lastError.
+ *
+ * On failure, returns null and stores a human-readable reason on
+ * `installAgentChattr.lastError` so callers can surface it without
+ * changing the return shape.
+ */
+function installAgentChattr(dir) {
+  if (!dir) {
+    installAgentChattr.lastError = "installAgentChattr: dir is required";
+    return null;
+  }
+  installAgentChattr.lastError = null;
+  const setError = (msg) => { installAgentChattr.lastError = msg; return null; };
+
+  // --- Per-target lock ---
+  const lockFile = `${dir}.install.lock`;
+  try { fs.mkdirSync(path.dirname(lockFile), { recursive: true }); }
+  catch (e) { return setError(`Cannot create parent of ${dir}: ${e.message}`); }
+
+  let acquired = false;
+  const deadline = Date.now() + INSTALL_LOCK_WAIT_TOTAL_MS;
+  while (!acquired) {
+    try {
+      fs.writeFileSync(lockFile, `${process.pid}:${Date.now()}`, { flag: "wx" });
+      acquired = true;
+    } catch (e) {
+      if (e.code !== "EEXIST") return setError(`Cannot create install lock ${lockFile}: ${e.message}`);
+      if (_isLockStale(lockFile)) {
+        const sideline = `${lockFile}.stale.${process.pid}.${Date.now()}`;
+        try {
+          fs.renameSync(lockFile, sideline);
+          try { fs.unlinkSync(sideline); } catch {}
+        } catch (renameErr) {
+          if (renameErr.code !== "ENOENT") {
+            return setError(`Cannot reclaim stale lock ${lockFile}: ${renameErr.message}`);
+          }
+        }
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        const info = _readLock(lockFile) || { pid: "?", ts: 0 };
+        return setError(`Another install is in progress at ${dir} (pid ${info.pid}); timed out after ${INSTALL_LOCK_WAIT_TOTAL_MS}ms. Re-run after it finishes, or remove ${lockFile} if stale.`);
+      }
+      try { execSync(`sleep ${INSTALL_LOCK_POLL_MS / 1000}`); }
+      catch { /* sleep interrupted; loop will recheck */ }
+    }
+  }
+
+  try {
+    return _installAgentChattrLocked(dir, setError);
+  } finally {
+    try { fs.unlinkSync(lockFile); } catch {}
+  }
+}
+installAgentChattr.lastError = null;
+
+function _installAgentChattrLocked(dir, setError) {
+  const runPy = path.join(dir, "run.py");
+  const venvPython = path.join(dir, ".venv", "bin", "python");
+  let venvJustCreated = false;
+
+  // 1. Clone if run.py is missing.
+  if (!fs.existsSync(runPy)) {
+    if (fs.existsSync(dir)) {
+      let entries;
+      try { entries = fs.readdirSync(dir); }
+      catch (e) { return setError(`Cannot read ${dir}: ${e.message}`); }
+      const isEmpty = entries.length === 0;
+      if (isEmpty) {
+        try { fs.rmSync(dir, { recursive: true, force: true }); }
+        catch (e) { return setError(`Cannot remove empty dir ${dir}: ${e.message}`); }
+      } else if (fs.existsSync(path.join(dir, ".git"))) {
+        const remote = _run(`git -C "${dir}" remote get-url origin 2>/dev/null`);
+        if (remote && remote.includes("agentchattr")) {
+          try { fs.rmSync(dir, { recursive: true, force: true }); }
+          catch (e) { return setError(`Cannot remove failed clone at ${dir}: ${e.message}`); }
+        } else {
+          return setError(`Refusing to overwrite ${dir}: contains a non-AgentChattr git repo`);
+        }
+      } else {
+        return setError(`Refusing to overwrite ${dir}: directory exists with unrelated content`);
+      }
+    }
+    try { fs.mkdirSync(path.dirname(dir), { recursive: true }); }
+    catch (e) { return setError(`Cannot create parent of ${dir}: ${e.message}`); }
+    const cloneResult = _run(`git clone "${AGENTCHATTR_REPO}" "${dir}" 2>&1`, { timeout: 60000 });
+    if (cloneResult === null) return setError(`git clone of ${AGENTCHATTR_REPO} into ${dir} failed`);
+    if (!fs.existsSync(runPy)) return setError(`Clone completed but run.py missing at ${dir}`);
+  }
+
+  // 2. Create venv if missing.
+  if (!fs.existsSync(venvPython)) {
+    const venvResult = _run(`python3 -m venv "${path.join(dir, ".venv")}" 2>&1`, { timeout: 60000 });
+    if (venvResult === null) return setError(`python3 -m venv failed at ${dir}/.venv (is python3 installed?)`);
+    if (!fs.existsSync(venvPython)) return setError(`venv created but ${venvPython} missing`);
+    venvJustCreated = true;
+  }
+
+  // 3. Install requirements only when the venv was just (re)created.
+  if (venvJustCreated) {
+    const reqFile = path.join(dir, "requirements.txt");
+    if (fs.existsSync(reqFile)) {
+      const pipResult = _run(`"${venvPython}" -m pip install -r "${reqFile}" 2>&1`, { timeout: 120000 });
+      if (pipResult === null) return setError(`pip install -r ${reqFile} failed`);
+    }
+  }
+  return dir;
+}
+
+/**
+ * Get spawn args for launching AgentChattr from its cloned directory.
+ * Returns { command, spawnArgs, cwd } or null if not fully installed.
+ * Requires .venv/bin/python — never falls back to bare python3.
+ */
+function chattrSpawnArgs(dir, extraArgs) {
+  if (!dir) return null;
+  const venvPython = path.join(dir, ".venv", "bin", "python");
+  if (!fs.existsSync(path.join(dir, "run.py")) || !fs.existsSync(venvPython)) return null;
+  return { command: venvPython, spawnArgs: ["run.py", ...(extraArgs || [])], cwd: dir };
+}
+
+module.exports = {
+  AGENTCHATTR_REPO,
+  findAgentChattr,
+  installAgentChattr,
+  chattrSpawnArgs,
+};

package/server/routes.js

@@ -69,6 +69,7 @@ router.put("/api/config", (req, res) => {
 // ─── Chat (AgentChattr proxy) ──────────────────────────────────────────────
 
 const { resolveProjectChattr } = require("./config");
+const { installAgentChattr, findAgentChattr } = require("./install-agentchattr");
 
 function getChattrConfig(projectId) {
   const resolved = resolveProjectChattr(projectId);
@@ -590,21 +591,26 @@ router.post("/api/setup", (req, res) => {
         const wtDir = path.join(parentDir, `${dirName}-${agent}`);
         if (!fs.existsSync(wtDir)) continue;
 
-        // AGENTS.md — use template with placeholder substitution (matches CLI)
+        // AGENTS.md — always (re)write from template so role definitions
+        // stay in sync with templates/seeds/ on every project (re)creation.
+        // Previously this was guarded by `!exists`, so if a worktree already
+        // had any AGENTS.md (stale, hand-edited, or empty) it was preserved
+        // forever and agents could launch with no/outdated role definition.
         const agentsMd = path.join(wtDir, "AGENTS.md");
-        if (!fs.existsSync(agentsMd)) {
-          const seedSrc = path.join(TEMPLATES_DIR, "seeds", `${agent}.AGENTS.md`);
-          if (fs.existsSync(seedSrc)) {
-            let content = fs.readFileSync(seedSrc, "utf-8");
-            content = content.replace(/\{\{reviewer_github_user\}\}/g, reviewerUser);
-            content = content.replace(/\{\{reviewer_token_path\}\}/g, reviewerTokenPath);
-            fs.writeFileSync(agentsMd, content);
-          } else {
-            // Fallback stub if template missing
-            fs.writeFileSync(agentsMd, `# ${dirName} — ${agent.charAt(0).toUpperCase() + agent.slice(1)} Agent\n\nRepo: ${body.repo}\nRole: ${agent === "head" ? "Owner" : agent.startsWith("reviewer") ? "Reviewer" : "Builder"}\n`);
-          }
-          seeded.push(`${agent}/AGENTS.md`);
+        const seedSrc = path.join(TEMPLATES_DIR, "seeds", `${agent}.AGENTS.md`);
+        if (!fs.existsSync(seedSrc)) {
+          // Hard fail: missing seed means role is undefined. Better to surface
+          // the error than silently write a generic stub.
+          return res.json({
+            ok: false,
+            error: `Missing seed template: templates/seeds/${agent}.AGENTS.md`,
+          });
         }
+        let agentsContent = fs.readFileSync(seedSrc, "utf-8");
+        agentsContent = agentsContent.replace(/\{\{reviewer_github_user\}\}/g, reviewerUser);
+        agentsContent = agentsContent.replace(/\{\{reviewer_token_path\}\}/g, reviewerTokenPath);
+        fs.writeFileSync(agentsMd, agentsContent);
+        seeded.push(`${agent}/AGENTS.md`);
 
         // CLAUDE.md — use template with placeholder substitution (matches CLI)
         const claudeMd = path.join(wtDir, "CLAUDE.md");
@@ -645,9 +651,28 @@ router.post("/api/setup", (req, res) => {
       const parentDir = path.dirname(workingDir);
       const backends = body.backends;
 
-      // Per-project: isolated config dir + data dir
-      const projectConfigDir = path.join(workingDir, "agentchattr");
-      fs.mkdirSync(projectConfigDir, { recursive: true });
+      // Phase 2D / #181: config.toml lives at the per-project AgentChattr
+      // clone ROOT (~/.quadwork/{id}/agentchattr/), not inside the user's
+      // project working_dir. AgentChattr's run.py loads ROOT/config.toml
+      // and ignores --config, so the toml has to be at the same path the
+      // clone lives at. Same path matches what writeQuadWorkConfig()
+      // persists in agentchattr_dir (#182) and what the CLI wizard
+      // writes (#184).
+      //
+      // We install the clone *here*, before writing config.toml. The
+      // install must run first because installAgentChattr() refuses to
+      // overwrite a non-empty directory it doesn't recognize — if we
+      // mkdir + write config.toml first, the subsequent install in
+      // add-config would see "unrelated content" and reject the dir,
+      // breaking first-run web project creation (t2a's review of #195).
+      const projectConfigDir = path.join(CONFIG_DIR, dirName, "agentchattr");
+      if (!findAgentChattr(projectConfigDir)) {
+        const installResult = installAgentChattr(projectConfigDir);
+        if (!installResult) {
+          const reason = installAgentChattr.lastError || "unknown error";
+          return res.json({ ok: false, error: `AgentChattr install failed at ${projectConfigDir}: ${reason}` });
+        }
+      }
       const dataDir = path.join(projectConfigDir, "data");
       fs.mkdirSync(dataDir, { recursive: true });
       const tomlPath = path.join(projectConfigDir, "config.toml");
@@ -697,19 +722,25 @@ router.post("/api/setup", (req, res) => {
     }
     case "add-config": {
       const { id, name, repo, workingDir, backends } = body;
+      const autoApprove = body.auto_approve !== false; // default true
       // Use directory basename for sibling paths (matches CLI wizard)
       const dirName = path.basename(workingDir);
       const parentDir = path.dirname(workingDir);
       let cfg;
       try { cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8")); }
-      catch { cfg = { port: 8400, agentchattr_url: "http://127.0.0.1:8300", projects: [] }; }
+      catch { cfg = { port: 8400, agentchattr_url: "http://127.0.0.1:8300", agentchattr_dir: path.join(os.homedir(), ".quadwork", "agentchattr"), projects: [] }; }
       if (cfg.projects.some((p) => p.id === id)) return res.json({ ok: true, message: "Project already in config" });
-      // Match CLI wizard agent structure: { cwd, command }
+      // Match CLI wizard agent structure: { cwd, command, auto_approve, mcp_inject }
       const agents = {};
       for (const agentId of ["head", "reviewer1", "reviewer2", "dev"]) {
+        const cmd = (backends && backends[agentId]) || "claude";
+        const cliBase = cmd.split("/").pop().split(" ")[0];
+        const injectMode = cliBase === "codex" ? "proxy_flag" : cliBase === "gemini" ? "env" : "flag";
         agents[agentId] = {
           cwd: path.join(parentDir, `${dirName}-${agentId}`),
-          command: (backends && backends[agentId]) || "claude",
+          command: cmd,
+          auto_approve: autoApprove,
+          mcp_inject: injectMode,
         };
       }
       // Use pre-assigned ports/token from agentchattr-config step if provided,
@@ -732,12 +763,27 @@ router.post("/api/setup", (req, res) => {
         while (usedMcpPorts.has(mcp_sse_port)) mcp_sse_port++;
       }
       if (!agentchattr_token) agentchattr_token = crypto.randomBytes(16).toString("hex");
+
+      // Phase 2D / #181: clone AgentChattr per-project before saving config.
+      // The path here must match the one written into agentchattr_dir below
+      // and the one agentchattr-config writes config.toml into.
+      const perProjectDir = path.join(CONFIG_DIR, id, "agentchattr");
+      if (!findAgentChattr(perProjectDir)) {
+        const installResult = installAgentChattr(perProjectDir);
+        if (!installResult) {
+          const reason = installAgentChattr.lastError || "unknown error";
+          return res.json({ ok: false, error: `AgentChattr install failed at ${perProjectDir}: ${reason}` });
+        }
+      }
+
       cfg.projects.push({
         id, name, repo, working_dir: workingDir, agents,
         agentchattr_url: `http://127.0.0.1:${chattrPort}`,
         agentchattr_token,
         mcp_http_port,
         mcp_sse_port,
+        // Per-project AgentChattr clone path (Option B / #181).
+        agentchattr_dir: perProjectDir,
       });
       const dir = path.dirname(CONFIG_PATH);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });