multi-agent-workbench 0.1.4 → 0.2.0

package/README.md

@@ -1,57 +1,90 @@
 # Multi-Agent Workbench
 
-Run multiple coding-agent CLIs in parallel with isolated worktrees, micro-task queues, handoff history, and live status.
+Run Claude Code, Codex and Antigravity CLIs in parallel. Each agent works in its own git worktree, takes small tasks from its own queue, and reports commits, check results and output to a live status file and dashboard.
+
+> **Warning:** `maw` starts agents with their permission prompts disabled (`--dangerously-skip-permissions`, `--dangerously-bypass-approvals-and-sandbox`). They can run any command as your user. Only use it on repositories and machines where that is acceptable, and review every commit before merging.
+
+## Requirements
+
+- Node.js 20 or newer
+- A git repository with at least one commit
+- At least one agent CLI, logged in: [`claude`](https://docs.claude.com/en/docs/claude-code), [`codex`](https://github.com/openai/codex) or `agy` (Antigravity)
 
 ## Quick start
 
-Create `tasks.json` in your project:
+```bash
+npm install -g multi-agent-workbench
+cd your-project
+maw init            # writes a starter tasks.json
+# edit tasks.json
+maw doctor          # are the agents installed and logged in?
+maw run --dry-run   # validate the plan
+maw                 # run it
+maw dashboard       # in another terminal: http://127.0.0.1:4317
+```
+
+Without installing: `npx multi-agent-workbench <command>`.
+
+## tasks.json
 
 ```json
 [
-  {"id":"L1","owner":"claude","command":"claude","worktree":"../project-claude","task":"API task","prompt":"Implement the API task and commit it."},
-  {"id":"C1","owner":"codex","command":"codex","worktree":"../project-codex","task":"Frontend task","prompt":"Implement the frontend task and commit it."},
-  {"id":"A1","owner":"antigravity","command":"agy","worktree":"../project-agy","task":"QA task","prompt":"Audit the current changes, fix only clear issues, and commit them."}
+  { "id": "L1", "owner": "claude", "task": "Orders API", "prompt": "Add GET /api/orders with pagination. Run the API tests and commit.", "check": "npm test -- orders" },
+  { "id": "C1", "owner": "codex", "task": "Orders page", "prompt": "Build the orders page. Run lint and commit." },
+  { "id": "A1", "owner": "antigravity", "command": "agy", "task": "QA", "depends_on": ["L1", "C1"], "prompt": "Merge maw/claude and maw/codex into this branch, run all tests, fix only clear bugs, and commit." }
 ]
 ```
 
-Install and run:
+- Each **owner** has a queue. Queues run in parallel; tasks in one queue run in order.
+- Each owner gets a worktree at `../<repo>-<owner>` on branch `maw/<owner>`, created automatically. Override with `worktree`, `branch` and `base`.
+- `depends_on` waits for other tasks; if one fails, dependents are skipped.
+- `check` is a shell command run after the agent finishes. If it fails, the task is blocked.
+- If a task is blocked, the rest of that owner's queue is skipped.
+- `model`, `effort` and `timeout_minutes` can be set per task (or with `CLAUDE_MODEL`, `CODEX_MODEL`, `AGY_MODEL` and the matching `*_EFFORT` env vars).
 
-```bash
-npm install -g multi-agent-workbench
-multi-agent-workbench init
-# edit tasks.json for your project
-multi-agent-workbench doctor
-multi-agent-workbench
-# or without installing
-npx multi-agent-workbench init
-npx multi-agent-workbench
-```
+Full field reference: [`multi-agent-workbench/references/task-schema.md`](multi-agent-workbench/references/task-schema.md).
 
-The supervisor reads `tasks.json` from the current project and writes `.agent-workbench/status.json` and `.agent-workbench/supervisor.log`. Review each commit before merging or deploying.
+## Commands
 
-## Use as a Codex skill
+| Command | What it does |
+|---|---|
+| `maw init [--force]` | Create a starter `tasks.json`. Won't overwrite without `--force`. |
+| `maw doctor` | Check the agents used in `tasks.json` (or all agents) are installed and logged in. Exits 1 if any are not. Never prints account details. |
+| `maw` / `maw run` | Run the queues. Exits 0 only if every task is done. `--dry-run` validates and prints the plan. |
+| `maw status` | Summarize the last run. |
+| `maw dashboard [--port N]` | Live status page on localhost (agents, tasks, commits, recent output). |
+| `maw install-skill` | Install the planning skill for Codex and Claude Code (`--codex` / `--claude` for one). |
 
-Clone the repository into your Codex skills directory:
+All commands accept `--tasks <file>` to use a different task file.
 
-```bash
-git clone https://github.com/ruhul0/multi-agent-workbench.git \
-  ~/.codex/skills/multi-agent-workbench
-```
+## Output
+
+- `.agent-workbench/status.json`: every task's state, real commit (read from git, not guessed from output), new commits, uncommitted changes, check result and last 30 lines of output
+- `.agent-workbench/logs/<id>.log`: full output per task
+- `.agent-workbench/supervisor.log`: event log
 
-Then invoke it in a Codex task with:
+Add `.agent-workbench/` to your project's `.gitignore`.
 
-```text
-Use $multi-agent-workbench to split this project into micro-tasks, assign frontend work to Codex, backend work to Claude, QA to Antigravity, and report live progress.
+## Use as a skill
+
+The skill tells a coordinating agent how to plan micro-tasks, write `tasks.json`, run `maw` and review the results.
+
+```bash
+maw install-skill
 ```
 
-The skill instructions are in `multi-agent-workbench/SKILL.md`. The Node.js CLI and the skill are independent: use the skill for planning/orchestration guidance, and use `maw` to launch workers.
+This copies the skill to `~/.codex/skills/multi-agent-workbench` and `~/.claude/skills/multi-agent-workbench`. Then ask:
 
-## Agent login check
+- Codex: `Use $multi-agent-workbench to split this into micro-tasks: frontend to Codex, backend to Claude, QA to Antigravity.`
+- Claude Code: `/multi-agent-workbench split this into micro-tasks …`
 
-Before assigning work, run:
+## Development
 
 ```bash
-maw doctor
+npm test        # end-to-end tests with a fake agent CLI
+npm run check   # syntax check
 ```
 
-It checks whether `claude`, `codex`, and `agy` are available without printing credentials.
+## License
+
+MIT

package/bin/maw.mjs

@@ -1,46 +1,114 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { spawnSync } from "node:child_process";
-import process from "node:process";
+import { writeFile, readFile, cp, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
-import { writeFile } from "node:fs/promises";
-
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const supervisor = resolve(packageRoot, "multi-agent-workbench/scripts/supervisor.mjs");
-const command = process.argv[2];
-if (command === "--help" || command === "-h") {
-  console.log("multi-agent-workbench — run Claude and Codex tasks in parallel");
-  console.log("\nCommands:\n  maw init    Create a starter tasks.json\n  maw doctor Check agent CLIs and authentication\n  maw         Run the task queue in the current project");
-  process.exit(0);
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import process from "node:process";
+import { runWorkbench } from "../multi-agent-workbench/scripts/supervisor.mjs";
+import { doctor } from "../multi-agent-workbench/scripts/doctor.mjs";
+import { dashboard } from "../multi-agent-workbench/scripts/dashboard.mjs";
+
+const HELP = `multi-agent-workbench (maw) — run Claude Code, Codex and Antigravity tasks in parallel git worktrees
+
+Usage:
+  maw init [--force]       Create a starter tasks.json in the current project
+  maw doctor               Check that the agents used in tasks.json are installed and logged in
+  maw run [--dry-run]      Run the task queue (default command). --dry-run validates and prints the plan
+  maw status               Print the latest .agent-workbench/status.json as a summary
+  maw dashboard [--port N] Serve a live status page on http://127.0.0.1:4317
+  maw install-skill        Install the planning skill for Codex and Claude Code
+                           (--codex or --claude to pick one)
+
+Options:
+  --tasks <file>           Use a different task file (default: tasks.json)
+  -h, --help               Show this help
+  -v, --version            Show the version
+
+Agents run with permission prompts disabled inside their worktrees. Review every commit before merging.`;
+
+const argv = process.argv.slice(2);
+const flag = (name) => argv.includes(name);
+const value = (name) => { const i = argv.indexOf(name); return i >= 0 ? argv[i + 1] : undefined; };
+const command = argv.find((a, i) => !a.startsWith("-") && !["--tasks", "--port"].includes(argv[i - 1])) || "run";
+const taskPath = value("--tasks");
+
+async function main() {
+  if (flag("-h") || flag("--help") || command === "help") { console.log(HELP); return 0; }
+  if (flag("-v") || flag("--version")) {
+    const pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+    console.log(pkg.version);
+    return 0;
+  }
+  switch (command) {
+    case "init": return init();
+    case "doctor": return (await doctor({ taskPath })) ? 0 : 1;
+    case "run": {
+      const { ok } = await runWorkbench({ taskPath, dryRun: flag("--dry-run") });
+      return process.exitCode === 130 ? 130 : ok ? 0 : 1;
+    }
+    case "status": return status();
+    case "install-skill": return installSkill();
+    case "dashboard": {
+      const port = Number(value("--port") || 4317);
+      if (!Number.isInteger(port) || port <= 0) throw new Error("--port must be a positive integer");
+      dashboard({ port });
+      return null; // keep the server running
+    }
+    default:
+      console.error(`Unknown command "${command}".\n\n${HELP}`);
+      return 2;
+  }
 }
-if (command === "doctor") {
-  const checks = [
-    ["claude", ["auth", "status"]],
-    ["codex", ["login", "status"]],
-    ["agy", ["--help"]],
+
+async function init() {
+  const target = resolve(process.cwd(), taskPath || "tasks.json");
+  if (existsSync(target) && !flag("--force")) {
+    console.error(`${target} already exists. Edit it, or run \`maw init --force\` to overwrite it.`);
+    return 1;
+  }
+  const tasks = [
+    { id: "L1", owner: "claude", command: "claude", task: "Backend task", prompt: "Implement the backend task, run its tests, and commit the result." },
+    { id: "C1", owner: "codex", command: "codex", task: "Frontend task", prompt: "Implement the frontend task, run its tests, and commit the result." },
+    { id: "A1", owner: "antigravity", command: "agy", task: "QA task", depends_on: ["L1", "C1"], prompt: "Review the latest changes on this branch, fix only clear issues, and commit them." },
   ];
-  for (const [name, args] of checks) {
-    const result = spawnSync(name, args, { encoding: "utf8", timeout: 10000 });
-    const installed = !result.error;
-    const output = `${result.stdout || ""}${result.stderr || ""}`.replace(/token[^\n]*/gi, "token [redacted]").trim();
-    console.log(`${installed ? "✓" : "✗"} ${name}${installed ? ` — ${output.split("\n")[0] || "available"}` : " — not installed"}`);
+  await writeFile(target, JSON.stringify(tasks, null, 2) + "\n");
+  console.log(`Created ${target}.\nEdit the prompts, then run \`maw doctor\` and \`maw\`.`);
+  return 0;
+}
+
+async function installSkill() {
+  const source = fileURLToPath(new URL("../multi-agent-workbench", import.meta.url));
+  const targets = [];
+  if (!flag("--claude")) targets.push(resolve(homedir(), ".codex/skills/multi-agent-workbench"));
+  if (!flag("--codex")) targets.push(resolve(homedir(), ".claude/skills/multi-agent-workbench"));
+  for (const target of targets) {
+    await mkdir(resolve(target, ".."), { recursive: true });
+    await cp(source, target, { recursive: true, force: true });
+    console.log(`Installed skill to ${target}`);
   }
-  process.exit(0);
+  console.log("Invoke it with $multi-agent-workbench in Codex or /multi-agent-workbench in Claude Code.");
+  return 0;
 }
-if (command === "init") {
-  const target = resolve(process.cwd(), "tasks.json");
-  await writeFile(target, JSON.stringify([
-    { id: "L1", owner: "claude", command: "claude", worktree: "../project-claude", task: "Backend task", prompt: "Implement the backend task and commit it." },
-    { id: "C1", owner: "codex", command: "codex", worktree: "../project-codex", task: "Frontend task", prompt: "Implement the frontend task and commit it." },
-    { id: "A1", owner: "antigravity", command: "agy", worktree: "../project-agy", task: "QA task", prompt: "Audit the current changes, fix only clear issues, and commit them." }
-  ], null, 2) + "\n", { flag: "wx" });
-  console.log(`Created ${target}. Edit it, then run maw.`);
-  process.exit(0);
+
+async function status() {
+  const path = resolve(process.cwd(), ".agent-workbench/status.json");
+  let s;
+  try { s = JSON.parse(await readFile(path, "utf8")); } catch {
+    console.error("No status yet. Run `maw` in this project first.");
+    return 1;
+  }
+  console.log(`${s.finished ? "Finished" : "Running"} · updated ${s.updated_at}`);
+  for (const t of s.tasks || []) {
+    console.log(`${t.state.padEnd(8)} ${t.id.padEnd(8)} ${t.owner.padEnd(12)} ${(t.commit || "—").padEnd(12)} ${t.task}${t.reason ? `  (${t.reason})` : ""}`);
+  }
+  return 0;
+}
+
+try {
+  const code = await main();
+  if (code !== null) process.exitCode = code;
+} catch (error) {
+  console.error(`maw: ${error.message}`);
+  process.exitCode = 2;
 }
-const child = spawn(process.execPath, [supervisor, ...process.argv.slice(2)], {
-  cwd: process.cwd(),
-  stdio: "inherit",
-  env: process.env,
-});
-child.on("exit", (code, signal) => process.exit(signal ? 1 : (code ?? 1)));

package/multi-agent-workbench/SKILL.md

@@ -1,22 +1,42 @@
 ---
 name: multi-agent-workbench
-description: Orchestrate multiple local coding-agent CLIs in isolated worktrees with micro-task queues, handoffs, live status, review gates, and optional deployment triggers.
+description: Split a software task into small, owned micro-tasks and run them in parallel across Claude Code, Codex and Antigravity CLIs using the `maw` supervisor (isolated git worktrees, dependencies, acceptance checks, live status). Use when the user asks to divide work between several coding agents or to run agents in parallel.
 ---
 
 # Multi-agent workbench
 
-Use this skill when a software task benefits from multiple coding-agent CLIs working in parallel.
+You are the coordinator. You plan, write `tasks.json`, start the `maw` supervisor, watch progress, and review results. The worker agents do the implementation.
 
-- Split work into bounded micro-tasks with owners, dependencies, and acceptance checks.
-- Give each agent its own Git worktree and branch.
-- Assign frontend/integration tasks to Codex and backend/data tasks to Claude when requested.
-- Capture commit, tests, changed files, output, and risks after every task.
-- Review and cherry-pick centrally; never auto-merge unreviewed work.
-- Keep production tests/builds on the VPS when the repository uses a server-side deployment workflow.
-- Expose current state, task, commit, output, and completed history in a live status file/dashboard.
+## 1. Preflight
 
-See `references/task-schema.md` for handoff records and `scripts/supervisor.mjs` for the Node.js supervisor.
+1. Confirm the project is a git repository with at least one commit and a clean working tree (`git status`).
+2. Check `maw` is available: `maw --version`, otherwise use `npx multi-agent-workbench`.
+3. Run `maw doctor`. Stop and tell the user about any agent marked ✗ (missing or not logged in). Agents marked `!` are installed but their login cannot be checked; mention it.
 
-## Invocation
+## 2. Plan micro-tasks
 
-Install the skill by cloning this repository to `~/.codex/skills/multi-agent-workbench`, then invoke it explicitly with `$multi-agent-workbench`. Before assigning tasks, run `maw doctor` and stop for any missing or unauthenticated worker. Typical ownership is Codex for frontend, Claude for backend logic, and Antigravity for QA/review, but preserve the user's requested assignment.
+- Keep each task small: one outcome, a handful of files, finishable in one agent run.
+- Give every task an `owner`, a precise `prompt`, and, where possible, a `check` command that proves it works (for example `npm test -- auth`).
+- Use the user's requested assignment. If none is given, a sensible default is Codex for frontend/integration, Claude for backend/data, Antigravity for QA/review.
+- Tasks for one owner run in order in that owner's worktree. Use `depends_on` when a task needs another owner's work; make the prompt say which branch to merge or inspect (each owner works on branch `maw/<owner>`).
+- Every prompt should end with: "Run the relevant tests and commit your changes with a clear message."
+- Avoid two owners editing the same files at the same time.
+
+The full field list is in `references/task-schema.md`. Validate the plan with `maw run --dry-run`, show it to the user, and wait for approval before running.
+
+## 3. Run and monitor
+
+- Start `maw` (it blocks until all queues finish; run it in the background if your environment allows).
+- Offer `maw dashboard` for a live page at http://127.0.0.1:4317, or read `.agent-workbench/status.json` / `maw status`.
+- Report to the user whenever a task finishes, fails, or is skipped. Per-task logs are in `.agent-workbench/logs/<id>.log`.
+- If a task is `blocked`, read its log, fix the prompt or split it, and re-run with a new `tasks.json` containing only the remaining work.
+
+## 4. Review and integrate
+
+- Never merge or deploy unreviewed work. For each `done` task, inspect the commit (`git -C <worktree> show <commit>`), run the project's tests, then merge or cherry-pick into the main branch.
+- Note tasks that finished "without a new commit" or with uncommitted changes; they need follow-up.
+- Summarize for the user: what each agent did, commits, test results, and remaining risks.
+
+## Safety
+
+`maw` runs every agent with permission prompts disabled (`--dangerously-skip-permissions` / `--dangerously-bypass-approvals-and-sandbox`) inside its worktree. Only run it on repositories and machines where that is acceptable, and say so to the user before the first run.

package/multi-agent-workbench/agents/openai.yaml

@@ -1,3 +1,3 @@
 interface:
   display_name: "Multi Agent Workbench"
-  short_description: "Help with Multi Agent Workbench tasks"
+  short_description: "Split work into micro-tasks and run Claude, Codex and Antigravity in parallel worktrees"

package/multi-agent-workbench/references/task-schema.md

@@ -1,3 +1,42 @@
-# Task and handoff schema
+# tasks.json schema
 
-Each task records an id, owner, worktree, prompt, dependencies, acceptance checks, state, commit, tests, and risks. Completed tasks must include the worker output and commit hash.
+`tasks.json` is either an array of tasks or an object `{ "tasks": [...] }`.
+
+| Field | Required | Default | Meaning |
+|---|---|---|---|
+| `id` | yes | — | Unique task id, e.g. `L1`. |
+| `prompt` | yes | — | Exact instruction sent to the agent. |
+| `owner` | yes* | agent name | Queue name. Tasks with the same owner run one after another. |
+| `command` | no | `owner` | Agent CLI: `claude`, `codex` (aliases `chatgpt`, `openai`) or `agy` (alias `antigravity`). *Either `owner` or `command` must name a known agent. |
+| `task` | no | start of prompt | Short title shown in status and dashboard. |
+| `worktree` | no | `../<repo>-<owner>` | Worktree path, relative to the project root. Created with `git worktree add` if missing. |
+| `branch` | no | `maw/<owner>` | Branch checked out in the worktree. Created from `base` if missing. |
+| `base` | no | `HEAD` | Starting point for a new branch. |
+| `depends_on` | no | `[]` | Task ids that must be `done` first. If one fails, this task is `skipped`. |
+| `check` | no | — | Shell command run in the worktree after the agent exits 0. Non-zero exit marks the task `blocked`. |
+| `model` | no | CLI default | Model passed to the agent (`CLAUDE_MODEL`, `CODEX_MODEL`, `AGY_MODEL` env vars also work). |
+| `effort` | no | CLI default | Reasoning effort (`CLAUDE_EFFORT`, `CODEX_EFFORT`, `AGY_EFFORT`). |
+| `timeout_minutes` | no | `60` | The agent is stopped and the task blocked after this long. |
+
+## Scheduling rules
+
+- Each owner's queue runs in file order. Different owners run in parallel.
+- A task starts when its `depends_on` tasks are `done` and its worktree is free.
+- If a task is `blocked`, the rest of that owner's queue is `skipped`, as are tasks depending on it.
+- `maw` exits 0 only if every task is `done`.
+
+## Task states and status record
+
+States: `pending` → `running` → `done` | `blocked` | `skipped`.
+
+Each entry in `.agent-workbench/status.json` → `tasks` records: `id`, `owner`, `agent`, `task`, `worktree`, `branch`, `depends_on`, `state`, `commit` (new `HEAD` after the task, or `null` if the agent made no commit), `commits` (all new commits), `dirty` (uncommitted changes left behind), `check` (`{ command, passed }`), `exit_code`, `reason`, `started_at`, `finished_at` and the last 30 `output` lines. Full output is in `.agent-workbench/logs/<id>.log`.
+
+## Example
+
+```json
+[
+  { "id": "L1", "owner": "claude", "task": "Orders API", "prompt": "Add GET /api/orders with pagination. Run the API tests and commit.", "check": "npm test -- orders" },
+  { "id": "C1", "owner": "codex", "task": "Orders page", "prompt": "Build the orders page against the existing API types. Run lint and commit." },
+  { "id": "A1", "owner": "antigravity", "command": "agy", "task": "QA", "depends_on": ["L1", "C1"], "prompt": "Merge branches maw/claude and maw/codex into this branch, run all tests, fix only clear bugs, and commit." }
+]
+```

package/multi-agent-workbench/scripts/agents.mjs

@@ -0,0 +1,51 @@
+// Agent CLI definitions shared by the supervisor and `maw doctor`.
+// Binaries can be overridden with MAW_BIN_CLAUDE, MAW_BIN_CODEX, MAW_BIN_AGY (useful for tests and custom installs).
+
+const ALIASES = { claude: "claude", codex: "codex", chatgpt: "codex", openai: "codex", agy: "agy", antigravity: "agy" };
+
+export const AGENTS = {
+  claude: {
+    label: "Claude Code",
+    bin: () => process.env.MAW_BIN_CLAUDE || "claude",
+    args: (task) => [
+      "-p", task.prompt,
+      "--dangerously-skip-permissions",
+      ...opt("--model", task.model || process.env.CLAUDE_MODEL),
+      ...opt("--effort", task.effort || process.env.CLAUDE_EFFORT),
+    ],
+    auth: ["auth", "status"],
+  },
+  codex: {
+    label: "Codex CLI",
+    bin: () => process.env.MAW_BIN_CODEX || "codex",
+    args: (task) => [
+      "exec",
+      "--dangerously-bypass-approvals-and-sandbox",
+      ...opt("-m", task.model || process.env.CODEX_MODEL),
+      ...(task.effort || process.env.CODEX_EFFORT ? ["-c", `model_reasoning_effort="${task.effort || process.env.CODEX_EFFORT}"`] : []),
+      task.prompt,
+    ],
+    auth: ["login", "status"],
+  },
+  agy: {
+    label: "Antigravity CLI",
+    bin: () => process.env.MAW_BIN_AGY || "agy",
+    args: (task) => [
+      "--dangerously-skip-permissions",
+      "--print", task.prompt,
+      ...opt("--model", task.model || process.env.AGY_MODEL),
+      ...opt("--effort", task.effort || process.env.AGY_EFFORT),
+    ],
+    auth: null, // agy has no non-interactive login check
+  },
+};
+
+function opt(flag, value) {
+  return value ? [flag, String(value)] : [];
+}
+
+/** Resolve a task's `command` (or `owner`) to an agent key, or null if unknown. */
+export function resolveAgent(task) {
+  const name = String(task.command || task.owner || "").trim().toLowerCase();
+  return ALIASES[name] || null;
+}

package/multi-agent-workbench/scripts/dashboard.mjs

@@ -0,0 +1,53 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+/** Serve a live, read-only status page for .agent-workbench/status.json on localhost. */
+export function dashboard({ root = process.cwd(), port = 4317, host = "127.0.0.1" } = {}) {
+  const statusPath = resolve(root, ".agent-workbench/status.json");
+  const server = createServer(async (req, res) => {
+    if (req.url === "/status.json") {
+      try {
+        const body = await readFile(statusPath, "utf8");
+        res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+        res.end(body);
+      } catch {
+        res.writeHead(404, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "No status yet. Run `maw` in this project." }));
+      }
+      return;
+    }
+    if (req.url === "/" || req.url === "/index.html") {
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(PAGE);
+      return;
+    }
+    res.writeHead(404).end();
+  });
+  server.listen(port, host, () => console.log(`maw dashboard: http://${host}:${port}  (Ctrl+C to stop)`));
+  return server;
+}
+
+const PAGE = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Agent Workbench</title><style>
+:root{--bg:#f7f7f5;--fg:#1d1d1b;--muted:#6b6b66;--card:#fff;--line:#e3e3de;--done:#1f7a3f;--run:#1d5fd1;--bad:#b42318;--skip:#8a6d00}
+@media (prefers-color-scheme:dark){:root{--bg:#141413;--fg:#ececea;--muted:#9a9a94;--card:#1e1e1c;--line:#33332f;--done:#4cc27a;--run:#6aa0ff;--bad:#ff7b6e;--skip:#e0b93a}}
+body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.5 system-ui,sans-serif}main{max-width:1100px;margin:0 auto;padding:24px 16px}
+h1{font-size:20px;margin:0 0 4px}.muted{color:var(--muted)}.grid{display:grid;gap:12px;grid-template-columns:repeat(auto-fill,minmax(300px,1fr));margin:16px 0}
+.card{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:14px;min-width:0}.row{display:flex;justify-content:space-between;gap:8px;align-items:baseline}
+.badge{font-size:12px;font-weight:600;text-transform:uppercase}.done{color:var(--done)}.running,.working{color:var(--run)}.blocked{color:var(--bad)}.skipped,.pending{color:var(--skip)}
+pre{background:var(--bg);border:1px solid var(--line);border-radius:6px;padding:8px;max-height:220px;overflow:auto;font-size:12px;white-space:pre-wrap;word-break:break-word;margin:8px 0 0}
+table{width:100%;border-collapse:collapse}td,th{text-align:left;padding:6px 8px;border-bottom:1px solid var(--line);vertical-align:top}code{font-size:12px}
+.wrap{overflow-x:auto}</style></head><body><main>
+<h1>Agent Workbench</h1><div class="muted" id="meta">Loading…</div>
+<div class="grid" id="agents"></div><h2>Tasks</h2><div class="card wrap"><table><thead><tr><th>Task</th><th>Owner</th><th>State</th><th>Commit</th><th>Notes</th></tr></thead><tbody id="tasks"></tbody></table></div>
+<h2>Recent events</h2><pre id="recent"></pre></main><script>
+const esc=s=>String(s??"").replace(/[&<>"]/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;"}[c]));
+async function tick(){try{const r=await fetch("/status.json",{cache:"no-store"});const s=await r.json();
+if(s.error){document.getElementById("meta").textContent=s.error;return}
+const age=Math.round((Date.now()-new Date(s.updated_at))/1000);
+document.getElementById("meta").textContent=(s.finished?"Finished":"Running")+" · updated "+age+"s ago · "+s.root;
+document.getElementById("agents").innerHTML=Object.entries(s.agents||{}).map(([o,a])=>'<div class="card"><div class="row"><strong>'+esc(o)+'</strong><span class="badge '+esc(a.state)+'">'+esc(a.state)+'</span></div><div>'+esc(a.task_id)+' — '+esc(a.task)+'</div><div class="muted">commit '+esc(a.commit||"—")+'</div><pre>'+esc((a.output||[]).join("\\n"))+'</pre></div>').join("")||'<div class="muted">No agent has started yet.</div>';
+document.getElementById("tasks").innerHTML=(s.tasks||[]).map(t=>'<tr><td><code>'+esc(t.id)+'</code> '+esc(t.task)+'</td><td>'+esc(t.owner)+'</td><td class="badge '+esc(t.state)+'">'+esc(t.state)+'</td><td><code>'+esc(t.commit||"—")+'</code></td><td class="muted">'+esc([t.reason,t.check&&("check "+(t.check.passed==null?"pending":t.check.passed?"passed":"failed")),t.dirty&&"uncommitted changes"].filter(Boolean).join(" · "))+'</td></tr>').join("");
+document.getElementById("recent").textContent=(s.recent||[]).slice().reverse().join("\\n");}catch(e){document.getElementById("meta").textContent="Waiting for status… "+e.message}}
+tick();setInterval(tick,2000);</script></body></html>`;

package/multi-agent-workbench/scripts/doctor.mjs

@@ -0,0 +1,46 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { AGENTS } from "./agents.mjs";
+import { loadTasks } from "./tasks.mjs";
+
+/**
+ * Check that each agent CLI is installed and logged in. Never prints CLI output,
+ * so account details and tokens stay out of terminals and logs.
+ * Returns true when every required agent is ready.
+ */
+export async function doctor({ root = process.cwd(), taskPath } = {}) {
+  const path = resolve(root, taskPath || "tasks.json");
+  let required = Object.keys(AGENTS);
+  let scope = "all supported agents (no tasks.json found)";
+  if (existsSync(path)) {
+    const tasks = await loadTasks(path, resolve(root));
+    required = [...new Set(tasks.map(t => t.agent))];
+    scope = `agents used in ${path}`;
+  }
+  console.log(`Checking ${scope}:`);
+  let ready = true;
+  for (const key of required) {
+    const def = AGENTS[key];
+    const bin = def.bin();
+    const probe = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 15000 });
+    if (probe.error) {
+      ready = false;
+      console.log(`✗ ${key} (${def.label}) — ${probe.error.code === "ENOENT" ? `\`${bin}\` not found on PATH` : probe.error.message}`);
+      continue;
+    }
+    if (!def.auth) {
+      console.log(`! ${key} (${def.label}) — installed; login cannot be checked non-interactively. Run \`${bin}\` once to confirm you are signed in.`);
+      continue;
+    }
+    const auth = spawnSync(bin, def.auth, { encoding: "utf8", timeout: 15000 });
+    if (auth.error || auth.status !== 0) {
+      ready = false;
+      console.log(`✗ ${key} (${def.label}) — installed but not logged in. Run \`${bin} ${key === "claude" ? "auth login" : "login"}\`.`);
+    } else {
+      console.log(`✓ ${key} (${def.label}) — installed and logged in`);
+    }
+  }
+  console.log(ready ? "\nAll required agents are ready." : "\nFix the agents marked ✗ before running tasks.");
+  return ready;
+}

package/multi-agent-workbench/scripts/supervisor.mjs

@@ -1,38 +1,269 @@
 #!/usr/bin/env node
-import { mkdir, readFile, writeFile, appendFile } from "node:fs/promises";
-import { spawn } from "node:child_process";
+// Multi-agent workbench supervisor: runs tasks.json across agent CLIs in isolated git worktrees.
+import { mkdir, writeFile, appendFile, rename, stat, realpath } from "node:fs/promises";
+import { spawn, spawnSync } from "node:child_process";
+import { resolve } from "node:path";
 import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { AGENTS } from "./agents.mjs";
+import { loadTasks } from "./tasks.mjs";
 
-const root = process.env.WORKBENCH_ROOT || process.cwd();
-const dir = `${root}/.agent-workbench`;
-await mkdir(dir, { recursive: true });
-const taskPath = process.env.WORKBENCH_TASKS || `${root}/tasks.json`;
-let tasks;
-try {
-  tasks = JSON.parse(await readFile(taskPath, "utf8"));
-} catch (error) {
-  console.error(`No tasks.json found at ${taskPath}. Create a task queue first; see the README example.`);
-  process.exitCode = 2;
-  process.exit();
+const OUTPUT_TAIL = 30;
+
+export async function runWorkbench({
+  root = process.env.WORKBENCH_ROOT || process.cwd(),
+  taskPath = process.env.WORKBENCH_TASKS,
+  dryRun = false,
+  quiet = false,
+} = {}) {
+  root = resolve(root);
+  taskPath = resolve(root, taskPath || "tasks.json");
+  const tasks = await loadTasks(taskPath, root);
+  const repoRoot = git(root, ["rev-parse", "--show-toplevel"]);
+  if (!repoRoot.ok) throw new Error(`${root} is not inside a git repository. Run \`git init\` and make a first commit.`);
+  if (!git(root, ["rev-parse", "--verify", "HEAD"]).ok) throw new Error("The repository has no commits yet. Make an initial commit so worktrees can be created.");
+
+  if (dryRun) {
+    for (const t of tasks) {
+      console.log(`${t.id}  ${t.owner} (${t.agent})  ${t.worktree} [${t.branch}]${t.depends_on.length ? `  after ${t.depends_on.join(", ")}` : ""}${t.check ? `  check: ${t.check}` : ""}`);
+    }
+    return { ok: true, tasks };
+  }
+
+  const dir = resolve(root, ".agent-workbench");
+  const logDir = resolve(dir, "logs");
+  await mkdir(logDir, { recursive: true });
+  const statePath = resolve(dir, "status.json");
+  const logPath = resolve(dir, "supervisor.log");
+
+  const state = {
+    root,
+    started_at: new Date().toISOString(),
+    finished: false,
+    agents: {},
+    tasks: tasks.map(t => ({ id: t.id, owner: t.owner, agent: t.agent, task: t.task, worktree: t.worktree, branch: t.branch, depends_on: t.depends_on, state: "pending", commit: null, commits: [], dirty: false, check: t.check ? { command: t.check, passed: null } : null, exit_code: null, reason: null, started_at: null, finished_at: null, output: [] })),
+    recent: [],
+  };
+  const rec = new Map(state.tasks.map(r => [r.id, r]));
+
+  // Serialized, atomic status writes so parallel agents can't corrupt status.json.
+  let writeChain = Promise.resolve();
+  const save = () => {
+    const snapshot = JSON.stringify({ ...state, updated_at: new Date().toISOString() }, null, 2);
+    writeChain = writeChain.then(async () => {
+      const tmp = `${statePath}.${process.pid}.tmp`;
+      await writeFile(tmp, snapshot);
+      await rename(tmp, statePath);
+    }).catch(() => {});
+    return writeChain;
+  };
+  const log = async (line) => {
+    const s = `[${new Date().toISOString()}] ${line}`;
+    state.recent = [...state.recent, s].slice(-40);
+    if (!quiet) console.log(`maw: ${line}`);
+    await appendFile(logPath, s + "\n");
+    await save();
+  };
+
+  // Create worktrees up front, sequentially (git holds a lock on worktree metadata).
+  const prepared = new Map();
+  for (const t of tasks) {
+    if (prepared.has(t.worktree)) continue;
+    const result = await ensureWorktree(root, t);
+    prepared.set(t.worktree, result);
+    if (!result.ok) await log(`worktree error for ${t.id}: ${result.error}`);
+    else if (result.created) await log(`created worktree ${t.worktree} on ${t.branch}`);
+  }
+
+  const children = new Set();
+  let interrupted = false;
+  const onSignal = (signal) => {
+    if (interrupted) return;
+    interrupted = true;
+    for (const c of children) c.kill("SIGTERM");
+    log(`received ${signal}; stopping agents`).finally(() => { process.exitCode = 130; });
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+
+  const finish = (r, stateName, reason) => {
+    r.state = stateName;
+    r.reason = reason || null;
+    r.finished_at = new Date().toISOString();
+  };
+
+  async function execute(t) {
+    const r = rec.get(t.id);
+    const wt = prepared.get(t.worktree);
+    r.state = "running";
+    r.started_at = new Date().toISOString();
+    state.agents[t.owner] = { state: "working", task_id: t.id, task: t.task, commit: null, output: [] };
+    await log(`${t.owner} start ${t.id}: ${t.task}`);
+
+    if (!wt.ok) {
+      finish(r, "blocked", wt.error);
+    } else {
+      const before = git(t.worktree, ["rev-parse", "HEAD"]).out;
+      const def = AGENTS[t.agent];
+      const taskLog = resolve(logDir, `${safeName(t.id)}.log`);
+      const res = await run(def.bin(), def.args(t), t.worktree, {
+        prefix: `[${t.owner}] `, quiet, logFile: taskLog, timeoutMs: t.timeout_minutes * 60_000, children,
+        onLine: (line) => { r.output = [...r.output, line].slice(-OUTPUT_TAIL); state.agents[t.owner].output = r.output; },
+      });
+      r.exit_code = res.code;
+      const after = git(t.worktree, ["rev-parse", "HEAD"]).out;
+      r.commit = after && after !== before ? after.slice(0, 12) : null;
+      r.commits = r.commit ? git(t.worktree, ["log", "--format=%h %s", `${before}..${after}`]).out.split("\n").filter(Boolean) : [];
+      r.dirty = git(t.worktree, ["status", "--porcelain"]).out.length > 0;
+
+      if (interrupted) finish(r, "blocked", "interrupted");
+      else if (res.error) finish(r, "blocked", res.error);
+      else if (res.code !== 0) finish(r, "blocked", `agent exited with code ${res.code}`);
+      else if (t.check) {
+        await log(`${t.owner} checking ${t.id}: ${t.check}`);
+        const c = await run(t.check, [], t.worktree, { shell: true, prefix: `[${t.owner} check] `, quiet, logFile: taskLog, timeoutMs: 30 * 60_000, children });
+        r.check.passed = c.code === 0 && !c.error;
+        if (r.check.passed) finish(r, "done");
+        else finish(r, "blocked", `check failed (exit ${c.code})`);
+      } else finish(r, "done");
+      if (r.state === "done" && !r.commit) r.reason = "finished without a new commit";
+    }
+
+    state.agents[t.owner] = { state: r.state, task_id: t.id, task: t.task, commit: r.commit, output: r.output };
+    await log(`${t.owner} ${r.state} ${t.id} ${r.commit || "—"}${r.reason ? ` (${r.reason})` : ""}`);
+  }
+
+  // Scheduler: each owner works through its own queue in order; a task starts once
+  // its dependencies are done and no other task is using the same worktree.
+  await save();
+  const running = new Map();
+  const busy = new Set();
+  const stoppedOwners = new Map();
+  while (true) {
+    for (const t of tasks) {
+      const r = rec.get(t.id);
+      if (r.state !== "pending") continue;
+      const failedDep = t.depends_on.find(d => ["blocked", "skipped"].includes(rec.get(d).state));
+      if (interrupted) finish(r, "skipped", "interrupted");
+      else if (stoppedOwners.has(t.owner)) finish(r, "skipped", `${t.owner} queue stopped after ${stoppedOwners.get(t.owner)} failed`);
+      else if (failedDep) finish(r, "skipped", `dependency ${failedDep} did not complete`);
+    }
+    if (!interrupted) {
+      const seenOwners = new Set();
+      for (const t of tasks) {
+        const r = rec.get(t.id);
+        if (r.state === "done" || r.state === "blocked" || r.state === "skipped") continue;
+        if (seenOwners.has(t.owner)) continue; // only the head of each owner's queue is eligible
+        seenOwners.add(t.owner);
+        if (r.state !== "pending" || busy.has(t.worktree)) continue;
+        if (!t.depends_on.every(d => rec.get(d).state === "done")) continue;
+        busy.add(t.worktree);
+        const p = execute(t).finally(() => {
+          busy.delete(t.worktree);
+          running.delete(t.id);
+          if (rec.get(t.id).state !== "done") stoppedOwners.set(t.owner, t.id);
+        });
+        running.set(t.id, p);
+      }
+    }
+    if (running.size === 0) {
+      const stuck = state.tasks.filter(r => r.state === "pending");
+      for (const r of stuck) finish(r, "skipped", interrupted ? "interrupted" : "waiting on a task queued behind it (check queue order vs depends_on)");
+      break;
+    }
+    await Promise.race(running.values());
+  }
+
+  process.off("SIGINT", onSignal);
+  process.off("SIGTERM", onSignal);
+  state.finished = true;
+  const counts = state.tasks.reduce((a, r) => ({ ...a, [r.state]: (a[r.state] || 0) + 1 }), {});
+  await log(`finished: ${Object.entries(counts).map(([k, v]) => `${v} ${k}`).join(", ")}`);
+  await writeChain;
+  return { ok: state.tasks.every(r => r.state === "done"), state };
 }
-if (!Array.isArray(tasks) || tasks.length === 0) {
-  console.error(`No tasks found in ${taskPath}. Add at least one Claude or Codex task.`);
-  process.exitCode = 2;
-  process.exit();
+
+async function ensureWorktree(root, t) {
+  const path = t.worktree;
+  let exists = false;
+  try { exists = (await stat(path)).isDirectory(); } catch {}
+  if (exists) {
+    const top = git(path, ["rev-parse", "--show-toplevel"]);
+    if (!top.ok || (await realpath(top.out)) !== (await realpath(path))) {
+      return { ok: false, error: `${path} exists but is not a git worktree; remove it or set a different "worktree"` };
+    }
+    return { ok: true, created: false };
+  }
+  const hasBranch = git(root, ["rev-parse", "--verify", "--quiet", `refs/heads/${t.branch}`]).ok;
+  const args = hasBranch ? ["worktree", "add", path, t.branch] : ["worktree", "add", "-b", t.branch, path, t.base];
+  const r = git(root, args);
+  return r.ok ? { ok: true, created: true } : { ok: false, error: r.err || `git worktree add failed for ${path}` };
+}
+
+function git(cwd, args) {
+  const r = spawnSync("git", args, { cwd, encoding: "utf8" });
+  return { ok: !r.error && r.status === 0, out: (r.stdout || "").trim(), err: (r.stderr || r.error?.message || "").trim() };
 }
-const statePath = `${dir}/status.json`, logPath = `${dir}/supervisor.log`;
-const state = { agents: {}, history: [], recent: [] };
-const save = () => writeFile(statePath, JSON.stringify({ ...state, updated_at: new Date().toISOString() }, null, 2));
-const log = async (line) => { const s = `[${new Date().toISOString()}] ${line}`; state.recent = [...state.recent, s].slice(-40); await appendFile(logPath, s + "\n"); await save(); };
-function run(cmd, args, cwd) { return new Promise(resolve => { const p = spawn(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"] }); let out = ""; p.stdout.on("data", x => { out += x; process.stdout.write(x); }); p.stderr.on("data", x => { out += x; process.stderr.write(x); }); p.on("close", code => resolve({ code: code ?? 1, out })); }); }
-async function execute(task) {
-  state.agents[task.owner] = { state: "working", task: task.task, commit: null, output: [] }; await log(`${task.owner} start ${task.id}`);
-  const command = task.command || task.owner;
-  const args = command === "claude" ? ["--model", process.env.CLAUDE_MODEL || "haiku", "--effort", "low", "-p", task.prompt, "--dangerously-skip-permissions"] : command === "agy" || command === "antigravity" ? ["--dangerously-skip-permissions", "--print", task.prompt] : ["exec", "-m", process.env.CODEX_MODEL || "gpt-6.1-sol", "-s", "danger-full-access", "--dangerously-bypass-approvals-and-sandbox", task.prompt];
-  const r = await run(command === "claude" ? "claude" : command === "agy" || command === "antigravity" ? "agy" : "codex", args, task.worktree);
-  const commit = (r.out.match(/\b[0-9a-f]{7,40}\b/g) || []).at(-1) || null;
-  state.agents[task.owner] = { state: r.code === 0 ? "done" : "blocked", task: task.task, commit, output: r.out.split("\n").slice(-30) };
-  state.history = [...state.history, { id: task.id, owner: task.owner, task: task.task, commit, state: state.agents[task.owner].state, output: state.agents[task.owner].output, finished_at: new Date().toISOString() }].slice(-40);
-  await log(`${task.owner} ${state.agents[task.owner].state} ${task.id} ${commit || "—"}`); return r.code === 0;
+
+function safeName(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+
+function run(cmd, args, cwd, { prefix = "", quiet = false, logFile, timeoutMs, children, onLine, shell = false } = {}) {
+  return new Promise((done) => {
+    let settled = false;
+    const settle = (v) => { if (!settled) { settled = true; done(v); } };
+    let child;
+    try {
+      child = spawn(cmd, args, { cwd, shell, stdio: ["ignore", "pipe", "pipe"], env: process.env });
+    } catch (error) {
+      return settle({ code: 127, error: `could not start ${cmd}: ${error.message}` });
+    }
+    children?.add(child);
+    let timedOut = false;
+    const timer = timeoutMs ? setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 10_000).unref();
+    }, timeoutMs) : null;
+    const pending = { stdout: "", stderr: "" };
+    const handle = (stream, chunk) => {
+      const text = pending[stream] + chunk.toString();
+      const lines = text.split("\n");
+      pending[stream] = lines.pop();
+      for (const line of lines) emit(line, stream);
+    };
+    const emit = (line, stream) => {
+      if (!quiet) (stream === "stderr" ? process.stderr : process.stdout).write(prefix + line + "\n");
+      if (logFile) appendFile(logFile, line + "\n").catch(() => {});
+      onLine?.(line);
+    };
+    child.stdout.on("data", (c) => handle("stdout", c));
+    child.stderr.on("data", (c) => handle("stderr", c));
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      children?.delete(child);
+      const msg = error.code === "ENOENT" ? `${cmd} is not installed or not on PATH` : error.message;
+      emit(msg, "stderr");
+      settle({ code: 127, error: msg });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      children?.delete(child);
+      for (const s of ["stdout", "stderr"]) if (pending[s]) emit(pending[s], s);
+      if (timedOut) settle({ code: code ?? 124, error: `timed out after ${Math.round(timeoutMs / 60000)} min` });
+      else settle({ code: code ?? (signal ? 128 : 1) });
+    });
+  });
+}
+
+// Allow running this file directly: node supervisor.mjs [--dry-run]
+if (import.meta.url === pathToFileURL(process.argv[1] || "").href) {
+  try {
+    const { ok } = await runWorkbench({ dryRun: process.argv.includes("--dry-run") });
+    if (!process.exitCode) process.exitCode = ok ? 0 : 1;
+  } catch (error) {
+    console.error(`maw: ${error.message}`);
+    process.exitCode = 2;
+  }
 }
-await Promise.all(Object.entries(Object.groupBy(tasks, t => t.owner)).map(async ([, queue]) => { for (const task of queue) if (!await execute(task)) break; }));

package/multi-agent-workbench/scripts/tasks.mjs

@@ -0,0 +1,93 @@
+import { readFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { resolveAgent } from "./agents.mjs";
+
+/** Load and validate tasks.json. Throws an Error with a user-facing message on any problem. */
+export async function loadTasks(taskPath, root) {
+  let raw;
+  try {
+    raw = await readFile(taskPath, "utf8");
+  } catch {
+    throw new Error(`No tasks.json found at ${taskPath}. Run \`maw init\` to create one.`);
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${taskPath} is not valid JSON: ${error.message}`);
+  }
+  const list = Array.isArray(data) ? data : data?.tasks;
+  if (!Array.isArray(list) || list.length === 0) {
+    throw new Error(`No tasks found in ${taskPath}. Add at least one task.`);
+  }
+  return normalizeTasks(list, root);
+}
+
+export function normalizeTasks(list, root) {
+  const repoName = basename(root);
+  const errors = [];
+  const ids = new Set();
+  const tasks = list.map((t, i) => {
+    const where = `task #${i + 1}${t?.id ? ` (${t.id})` : ""}`;
+    if (!t || typeof t !== "object") { errors.push(`${where}: must be an object`); return null; }
+    if (!t.id) errors.push(`${where}: missing "id"`);
+    else if (ids.has(t.id)) errors.push(`${where}: duplicate id "${t.id}"`);
+    ids.add(t.id);
+    if (!t.prompt) errors.push(`${where}: missing "prompt"`);
+    const agent = resolveAgent(t);
+    if (!agent) errors.push(`${where}: unknown agent "${t.command || t.owner}" (use claude, codex or agy)`);
+    const owner = t.owner || agent;
+    const deps = t.depends_on ?? t.dependencies ?? [];
+    if (!Array.isArray(deps)) errors.push(`${where}: "depends_on" must be an array of task ids`);
+    return {
+      id: String(t.id),
+      owner: String(owner),
+      agent,
+      task: t.task || t.prompt?.slice(0, 80) || "",
+      prompt: t.prompt,
+      worktree: resolve(root, t.worktree || `../${repoName}-${owner}`),
+      branch: t.branch || `maw/${owner}`,
+      base: t.base || "HEAD",
+      depends_on: Array.isArray(deps) ? deps.map(String) : [],
+      check: t.check || null,
+      model: t.model || null,
+      effort: t.effort || null,
+      timeout_minutes: Number(t.timeout_minutes) || 60,
+    };
+  });
+  if (errors.length) throw new Error(`Invalid tasks.json:\n  - ${errors.join("\n  - ")}`);
+
+  for (const t of tasks) for (const d of t.depends_on) {
+    if (!ids.has(d)) errors.push(`${t.id}: depends on unknown task "${d}"`);
+    if (d === t.id) errors.push(`${t.id}: depends on itself`);
+  }
+  // Owners sharing a worktree must also share a branch, otherwise checkouts collide.
+  const byPath = new Map();
+  for (const t of tasks) {
+    const prev = byPath.get(t.worktree);
+    if (prev && prev.branch !== t.branch) errors.push(`${t.id}: worktree ${t.worktree} is already used with branch ${prev.branch}`);
+    byPath.set(t.worktree, t);
+  }
+  if (!errors.length) {
+    const cycle = findCycle(tasks);
+    if (cycle) errors.push(`dependency cycle: ${cycle.join(" -> ")}`);
+  }
+  if (errors.length) throw new Error(`Invalid tasks.json:\n  - ${errors.join("\n  - ")}`);
+  return tasks;
+}
+
+function findCycle(tasks) {
+  const byId = new Map(tasks.map(t => [t.id, t]));
+  const state = new Map();
+  const stack = [];
+  const visit = (id) => {
+    if (state.get(id) === 2) return null;
+    if (state.get(id) === 1) return [...stack.slice(stack.indexOf(id)), id];
+    state.set(id, 1); stack.push(id);
+    for (const d of byId.get(id).depends_on) { const c = visit(d); if (c) return c; }
+    stack.pop(); state.set(id, 2);
+    return null;
+  };
+  for (const t of tasks) { const c = visit(t.id); if (c) return c; }
+  return null;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "multi-agent-workbench",
-  "version": "0.1.4",
-  "description": "Run multiple coding-agent CLIs in parallel with task queues, isolated worktrees, handoffs, and live status.",
+  "version": "0.2.0",
+  "description": "Run Claude Code, Codex and Antigravity CLIs in parallel git worktrees with task queues, dependencies, acceptance checks and a live status dashboard.",
   "type": "module",
   "bin": {
     "multi-agent-workbench": "bin/maw.mjs",
@@ -15,7 +15,8 @@
   ],
   "scripts": {
     "start": "node bin/maw.mjs",
-    "check": "node --check bin/maw.mjs && node --check multi-agent-workbench/scripts/supervisor.mjs",
+    "test": "node --test test/*.test.mjs",
+    "check": "node --check bin/maw.mjs && for f in multi-agent-workbench/scripts/*.mjs; do node --check $f || exit 1; done",
     "pack:check": "npm pack --dry-run"
   },
   "engines": {
@@ -24,13 +25,20 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ruhul0/multi-agent-workbench.git"
+    "url": "git+https://github.com/ruhul0/multi-agent-workbench.git"
   },
   "bugs": {
     "url": "https://github.com/ruhul0/multi-agent-workbench/issues"
   },
   "homepage": "https://github.com/ruhul0/multi-agent-workbench#readme",
-  "dependencies": {
-    "multi-agent-workbench": "github:ruhul0/multi-agent-workbench"
-  }
+  "keywords": [
+    "ai",
+    "agents",
+    "claude",
+    "codex",
+    "antigravity",
+    "multi-agent",
+    "git-worktree",
+    "cli"
+  ]
 }