multiclaw 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,19 +1,25 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
 import { readFileSync } from "fs";
 import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
+import { Command } from "commander";
 
-// src/commands/run.ts
-import * as path3 from "path";
-import { Orchestrator as OrchestratorImpl, runtimeRegistry } from "@multiclawcli/core";
+// src/commands/doctor.ts
+import {
+  detectProviders,
+  presentProviders,
+  resolveProvider,
+  specForProvider
+} from "@multiclawcli/core";
 
 // src/loader/loadConfig.ts
-import * as path from "path";
 import * as fs from "fs";
+import { createRequire } from "module";
+import * as path from "path";
 var DEFAULT_CONFIG_NAMES = ["multiclaw.config.ts", "multiclaw.config.js"];
+var CONFIG_HELPER_SPECIFIERS = ["multiclaw", "@multiclawcli/core"];
 function findConfig(configPath) {
   if (configPath) {
     const abs = path.resolve(process.cwd(), configPath);
@@ -24,19 +30,51 @@ function findConfig(configPath) {
     const abs = path.resolve(process.cwd(), name);
     if (fs.existsSync(abs)) return abs;
   }
-  throw new Error(`No config file found. Create multiclaw.config.ts in the current directory or use --config to specify a path.`);
+  throw new Error(
+    `No config file found. Create multiclaw.config.ts in the current directory or use --config to specify a path.`
+  );
 }
-async function loadConfig(configPath, requirement) {
-  const absPath = findConfig(configPath);
-  const { register } = await import("tsx/esm/api");
-  const unregister = register();
-  let mod;
+function resolveHelpersEntry() {
   try {
-    mod = await import(absPath);
-  } finally {
-    unregister();
+    return createRequire(import.meta.url).resolve("@multiclawcli/core");
+  } catch {
+    return void 0;
+  }
+}
+async function importConfig(absPath) {
+  const { createJiti } = await import("jiti");
+  const helpers = resolveHelpersEntry();
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    ...helpers ? { alias: Object.fromEntries(CONFIG_HELPER_SPECIFIERS.map((name) => [name, helpers])) } : {}
+  });
+  try {
+    return await jiti.import(absPath);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      [
+        `Failed to load config: ${absPath}`,
+        `  ${detail.split("\n")[0]}`,
+        `  Check the file for syntax errors, and that every package it imports is installed.`
+      ].join("\n")
+    );
   }
-  const config = mod.default ?? mod.config;
+}
+function unwrapConfig(mod) {
+  let value = mod;
+  for (let depth = 0; depth < 3; depth += 1) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) break;
+    const record = value;
+    const next = "default" in record ? record.default : record.config;
+    if (!next || typeof next !== "object" || Array.isArray(next)) break;
+    value = next;
+  }
+  return value;
+}
+async function loadConfig(configPath, requirement) {
+  const absPath = findConfig(configPath);
+  const config = unwrapConfig(await importConfig(absPath));
   if (!config || !Array.isArray(config.agents)) {
     throw new Error(`Invalid config format \u2014 expected: export default defineConfig({...})`);
   }
@@ -48,6 +86,361 @@ async function loadConfig(configPath, requirement) {
   return config;
 }
 
+// src/commands/doctor.ts
+function buildDoctorReport(detected, config) {
+  const present = presentProviders(detected);
+  const providers = detected.map((d) => {
+    const spec = specForProvider(d.id);
+    return {
+      id: d.id,
+      label: d.label,
+      status: d.status,
+      command: d.command,
+      version: d.version,
+      modelCount: spec?.models.length ?? 0,
+      modelSelection: spec?.modelSelection ?? "none",
+      authHint: spec?.auth.hint ?? "",
+      installHint: d.status === "missing" ? spec?.install.hint : void 0
+    };
+  });
+  const installedCount = present.length;
+  let configReport;
+  if (config) {
+    const defaultsProvider = config.defaults?.provider;
+    const defaultsProviderOk = !defaultsProvider || present.includes(defaultsProvider);
+    const agents2 = [...config.agents];
+    if (config.leader) agents2.push(config.leader);
+    const agentsWithMissingProvider = agents2.map((a) => ({ id: a.id, intended: resolveProvider(a, config) })).filter((a) => !present.includes(a.intended)).map((a) => a.id);
+    configReport = {
+      name: config.name,
+      defaultsProvider,
+      defaultsProviderOk,
+      agentsWithMissingProvider
+    };
+  }
+  return {
+    providers,
+    installedCount,
+    config: configReport,
+    runnable: installedCount > 0
+  };
+}
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var ANSI_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function color(enabled, code, text) {
+  return enabled ? `${code}${text}${RESET}` : text;
+}
+function formatDoctorReport(report, useColor = true) {
+  const lines = [];
+  const c = (code, text) => color(useColor, code, text);
+  const cell = (text, width, code) => {
+    const rendered = code ? color(useColor, code, text) : text;
+    const visible = text.replace(ANSI_RE, "").length;
+    return rendered + " ".repeat(Math.max(0, width - visible));
+  };
+  lines.push("");
+  lines.push(c(DIM, "multiclaw doctor \u2014 environment check"));
+  lines.push("");
+  lines.push(`${cell("provider", 12)}${cell("status", 10)}${cell("version", 14)}models  auth`);
+  for (const p of report.providers) {
+    const mark = p.status === "present" ? "\u2713 present" : "\u2717 missing";
+    const markCode = p.status === "present" ? GREEN : RED;
+    const version = p.version ?? (p.status === "present" ? "" : "\u2014");
+    const models = p.modelSelection === "none" ? "n/a" : String(p.modelCount);
+    const auth = p.authHint ? c(DIM, p.authHint) : "";
+    lines.push(
+      `${cell(p.label, 12)}${cell(mark, 10, markCode)}${cell(version, 14)}${cell(models, 7)}${auth}`
+    );
+    if (p.status === "missing" && p.installHint) {
+      lines.push(c(YELLOW, `  install: ${p.installHint}`));
+    }
+  }
+  if (report.config) {
+    lines.push("");
+    lines.push(c(DIM, `config: ${report.config.name ?? "(unnamed)"}`));
+    if (report.config.defaultsProvider) {
+      const ok = report.config.defaultsProviderOk;
+      lines.push(
+        `  default provider: ${report.config.defaultsProvider} ${ok ? c(GREEN, "\u2713 installed") : c(RED, "\u2717 not installed")}`
+      );
+    }
+    if (report.config.agentsWithMissingProvider.length > 0) {
+      lines.push(
+        c(
+          RED,
+          `  ${report.config.agentsWithMissingProvider.length} agent(s) need a provider that is not installed: ${report.config.agentsWithMissingProvider.join(", ")}`
+        )
+      );
+    } else {
+      lines.push(c(GREEN, "  all agents resolve to an installed provider \u2713"));
+    }
+  }
+  lines.push("");
+  if (report.runnable) {
+    lines.push(
+      c(
+        GREEN,
+        `\u2713 ${report.installedCount} of ${report.providers.length} providers available \u2014 multiclaw can run.`
+      )
+    );
+  } else {
+    lines.push(c(RED, `\u2717 no providers installed \u2014 install one of the above to run multiclaw.`));
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function doctorCommand(configPath) {
+  const detected = await detectProviders({ withVersion: true });
+  const config = await loadConfigSafe(configPath);
+  const report = buildDoctorReport(detected, config);
+  const useColor = !process.env.NO_COLOR && process.stdout.isTTY;
+  console.log(formatDoctorReport(report, useColor));
+  process.exitCode = report.runnable ? 0 : 1;
+}
+async function loadConfigSafe(configPath) {
+  try {
+    return await loadConfig(configPath);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { checkbox, input, Separator, select } from "@inquirer/prompts";
+import { detectProviders as detectProviders2, specForProvider as specForProvider2, tierModel } from "@multiclawcli/core";
+var AGENT_BLOCKS = {
+  backend: `    agents.productManager(),
+    agents.architect({ dependsOn: ["product-manager"] }),
+    agents.archDesignReviewer({ dependsOn: ["architect"] }),
+    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
+    agents.tester({ dependsOn: ["backend-developer"] }),
+    agents.codeReviewer({ dependsOn: ["tester"] }),
+    agents.devops({ dependsOn: ["tester"] }),`,
+  frontend: `    agents.architect(),
+    agents.uiDesigner({ dependsOn: ["architect"] }),
+    agents.uiDesignReviewer({ dependsOn: ["ui-designer"] }),
+    agents.frontendDeveloper({ dependsOn: ["ui-design-reviewer"] }),
+    agents.tester({ dependsOn: ["frontend-developer"] }),
+    agents.codeReviewer({ dependsOn: ["tester"] }),`,
+  fullstack: `    agents.productManager(),
+    agents.architect({ dependsOn: ["product-manager"] }),
+    agents.archDesignReviewer({ dependsOn: ["architect"] }),
+    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
+    agents.uiDesigner({ dependsOn: ["arch-design-reviewer"] }),
+    agents.uiDesignReviewer({ dependsOn: ["ui-designer"] }),
+    agents.frontendDeveloper({ dependsOn: ["backend-developer", "ui-design-reviewer"] }),
+    agents.tester({ dependsOn: ["frontend-developer"] }),
+    agents.codeReviewer({ dependsOn: ["tester"] }),
+    agents.devops({ dependsOn: ["tester"] }),`
+};
+var PRESET_DESCRIPTIONS = {
+  backend: "Product Manager \u2192 Architect \u2192 Arch Design Reviewer \u2192 Backend Developer \u2192 Tester \u2192 Code Reviewer + DevOps  (7 agents)",
+  frontend: "Architect \u2192 UI Designer \u2192 UI Design Reviewer \u2192 Frontend Developer \u2192 Tester \u2192 Code Reviewer  (6 agents)",
+  fullstack: "Product Manager \u2192 Architect \u2192 Arch Design Reviewer \u2192 Backend Developer + UI Designer \u2192 UI Design Reviewer \u2192 Frontend Developer \u2192 Tester \u2192 Code Reviewer + DevOps  (10 agents)"
+};
+function generateConfig(opts) {
+  const name = JSON.stringify(opts.projectName);
+  const workDir = JSON.stringify(opts.workDir);
+  const defaultsParts = [`provider: ${JSON.stringify(opts.provider)}`];
+  if (opts.model) defaultsParts.push(`model: ${JSON.stringify(opts.model)}`);
+  let agentBlock = AGENT_BLOCKS[opts.preset];
+  if (opts.overrides && opts.overrides.length > 0) {
+    for (const ov of opts.overrides) {
+      const id = ov.id;
+      const model = JSON.stringify(ov.model);
+      const re = new RegExp(`(agents\\.${id}\\([^)]*\\))`, "g");
+      agentBlock = agentBlock.replace(re, (match) => {
+        const inner = match.slice(id.length + 8, -1);
+        const sep = inner.trim() ? ", " : "";
+        return `agents.${id}({ ${inner}${sep}model: ${model} })`;
+      });
+    }
+  }
+  return `import { defineConfig, agents } from "multiclaw"
+
+export default defineConfig({
+  name: ${name},
+  workDir: ${workDir},
+  context: {
+    projectName: ${name},
+  },
+  defaults: {
+    ${defaultsParts.join(",\n    ")},
+  },
+  agents: [
+${agentBlock}
+  ],
+})
+`;
+}
+async function initCommand() {
+  const configPath = path2.resolve(process.cwd(), "multiclaw.config.ts");
+  if (fs2.existsSync(configPath)) {
+    console.error("\x1B[31mError: multiclaw.config.ts already exists\x1B[0m");
+    process.exit(1);
+  }
+  const defaultProjectName = path2.basename(process.cwd());
+  const projectName = await input({
+    message: "Project name:",
+    default: defaultProjectName
+  });
+  const preset = await select({
+    message: "Select a preset:",
+    choices: [
+      { value: "backend", name: `backend    \u2014 ${PRESET_DESCRIPTIONS.backend}` },
+      { value: "frontend", name: `frontend   \u2014 ${PRESET_DESCRIPTIONS.frontend}` },
+      { value: "fullstack", name: `fullstack  \u2014 ${PRESET_DESCRIPTIONS.fullstack}` }
+    ]
+  });
+  const detected = await detectProviders2({ withVersion: true });
+  const provider = await select({
+    message: "Which agent?",
+    choices: detected.map((d) => ({
+      value: d.id,
+      name: d.status === "present" ? `${d.label}  (${d.command}${d.version ? ` ${d.version}` : ""})` : `${d.label}  (not installed)`,
+      disabled: false
+    }))
+  });
+  const spec = specForProvider2(provider);
+  if (!spec) {
+    throw new Error(`Unknown provider: ${provider}`);
+  }
+  const modelAnswer = await select({
+    message: "Team model preference:",
+    choices: [
+      { value: "", name: "Role-based tier defaults (recommended)" },
+      new Separator("---"),
+      ...[
+        { label: "Strong (architect, devops)", tier: "strong" },
+        { label: "Balanced (backend, frontend)", tier: "balanced" },
+        { label: "Fast (reviewer, tester)", tier: "fast" }
+      ].map((t) => {
+        const m = tierModel(spec, t.tier);
+        return m ? { value: m, name: `${t.label}  \u2192  ${m}` } : void 0;
+      }).filter((x) => x !== void 0),
+      new Separator("---"),
+      ...spec.models.map((m) => ({ value: m.id, name: m.label }))
+    ]
+  });
+  const modelDefault = modelAnswer || void 0;
+  const overrideIds = await checkbox({
+    message: "Override model for specific agents? (space to select, enter to confirm)",
+    choices: [
+      { value: "leader", name: "\u2605 Leader" },
+      { value: "productManager", name: "Product Manager" },
+      { value: "architect", name: "Architect" },
+      { value: "archDesignReviewer", name: "Arch Design Reviewer" },
+      { value: "backendDeveloper", name: "Backend Developer" },
+      { value: "frontendDeveloper", name: "Frontend Developer" },
+      { value: "uiDesigner", name: "UI Designer" },
+      { value: "uiDesignReviewer", name: "UI Design Reviewer" },
+      { value: "tester", name: "Tester" },
+      { value: "codeReviewer", name: "Code Reviewer" },
+      { value: "devops", name: "DevOps" }
+    ]
+  });
+  const overrides = [];
+  for (const id of overrideIds) {
+    const ov = await select({
+      message: `Model for ${id}:`.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()),
+      choices: spec.models.map((m) => ({ value: m.id, name: m.label }))
+    });
+    overrides.push({ id, model: ov });
+  }
+  const workDir = await input({
+    message: "Work directory (where agents read and write files):",
+    default: "."
+  });
+  try {
+    fs2.writeFileSync(
+      configPath,
+      generateConfig({ preset, workDir, projectName, provider, model: modelDefault, overrides })
+    );
+    if (workDir !== ".") {
+      fs2.mkdirSync(path2.resolve(process.cwd(), workDir), { recursive: true });
+    }
+  } catch (err) {
+    console.error(`\x1B[31mError: Failed to create files: ${err.message}\x1B[0m`);
+    process.exit(1);
+  }
+  const detectedProvider = detected.find((d) => d.id === provider);
+  console.log("");
+  console.log(`\x1B[32m\u2713\x1B[0m Created multiclaw.config.ts`);
+  console.log(`  preset:   ${preset}  (${PRESET_DESCRIPTIONS[preset]})`);
+  console.log(`  agent:    ${spec.label}`);
+  if (detectedProvider?.status === "present") {
+    console.log(
+      `            ${detectedProvider.command}${detectedProvider.version ? ` ${detectedProvider.version}` : ""}`
+    );
+  }
+  console.log(`  model:    ${modelDefault || "role-based tier defaults"}`);
+  console.log(`  workDir:  ${workDir}`);
+  if (overrides.length > 0) {
+    console.log(`  overrides: ${overrides.map((o) => `${o.id}=${o.model}`).join(", ")}`);
+  }
+  console.log("");
+  if (detectedProvider?.status === "missing") {
+    console.log(`\x1B[33m\u26A0 ${spec.label} is not installed.\x1B[0m`);
+    console.log(`  ${spec.install.hint}`);
+    console.log("");
+  }
+  if (detectedProvider?.note) {
+    console.log(`\x1B[2m  Before your first run: ${detectedProvider.note}\x1B[0m`);
+    console.log("");
+  }
+  console.log(`> Run: multiclaw            (interactive console)`);
+  console.log(`       multiclaw run "..."  (headless)`);
+  console.log("");
+  console.log(
+    `\x1B[2mTip: the CLI resolves the "multiclaw" import itself, so the config runs either way.\x1B[0m`
+  );
+  console.log(
+    `\x1B[2m     \`npm i -D multiclaw\` adds editor autocomplete for defineConfig/agents.\x1B[0m`
+  );
+}
+
+// src/commands/run.ts
+import * as path4 from "path";
+import { Orchestrator as OrchestratorImpl } from "@multiclawcli/core";
+
+// src/lib.ts
+import {
+  detectProviders as detectProviders3,
+  presentProviders as presentProviders2,
+  resolveCommand,
+  runtimeRegistry
+} from "@multiclawcli/core";
+import { agents, defineConfig } from "@multiclawcli/core";
+async function assertRuntimesAvailable(config) {
+  const checked = /* @__PURE__ */ new Set();
+  for (const agent of config.agents) {
+    const name = agent.runtime ?? "acp";
+    if (!runtimeRegistry.has(name)) {
+      const supported = runtimeRegistry.list().join(", ");
+      console.error(`\x1B[31mError: Unknown runtime "${name}". Supported: ${supported}\x1B[0m`);
+      process.exit(1);
+    }
+    const command = resolveCommand(agent, config);
+    const key = `${name}\0${command}`;
+    if (checked.has(key)) continue;
+    checked.add(key);
+    const info = await runtimeRegistry.get(name).describe({ command });
+    if (!info.available) {
+      const subject = `Command "${command}"`;
+      console.error(
+        `\x1B[31mError: ${subject} is not available. Make sure the CLI is installed.\x1B[0m`
+      );
+      process.exit(1);
+    }
+  }
+}
+
 // src/reporters/ConsoleReporter.ts
 var isFancy = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY === true;
 var S = isFancy ? { ok: "\u2713", fail: "\u2717", run: "\u203A", retry: "\u21BB", skip: "\u2298", warn: "\u26A0", bullet: "\xB7" } : { ok: "+", fail: "x", run: ">", retry: "~", skip: "-", warn: "!", bullet: "*" };
@@ -83,8 +476,16 @@ var ConsoleReporter = class {
 ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
         console.log(`${edge[1]}  ${S.run} ${e.payload.name.padEnd(46)}${edge[1]}`);
         console.log(`${edge[2]}${line}${edge[4]}${C.reset}`);
-        console.log(`${C.cyan}${S.bullet} Agents: ${e.payload.totalAgents}  Stages: ${e.payload.stages.length}${C.reset}
-`);
+        console.log(
+          `${C.cyan}${S.bullet} Agents: ${e.payload.totalAgents}  Stages: ${e.payload.stages.length}${C.reset}
+`
+        );
+        break;
+      }
+      case "orchestration:stages": {
+        console.log(
+          `${C.dim}${S.bullet} Plan applied \u2014 ${e.payload.stages.length} stages${C.reset}`
+        );
         break;
       }
       case "stage:start": {
@@ -114,14 +515,25 @@ ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
         break;
       }
       case "agent:retrying": {
-        console.log(`${C.yellow}${S.retry} ${e.payload.agentName} retry ${e.payload.attempt}/${e.payload.maxAttempts}: ${e.payload.error}${C.reset}`);
+        console.log(
+          `${C.yellow}${S.retry} ${e.payload.agentName} retry ${e.payload.attempt}/${e.payload.maxAttempts}: ${e.payload.error}${C.reset}`
+        );
+        break;
+      }
+      case "orchestration:warning": {
+        console.log(`${C.yellow}${S.warn} ${e.payload.message}${C.reset}`);
         break;
       }
       case "orchestration:complete": {
-        const { success, totalDuration, agentResults } = e.payload;
+        const { success, totalDuration, agentResults, reply } = e.payload;
+        if (reply) {
+          const mark = reply.mode === "ask" ? "?" : S.ok;
+          console.log(`
+${C.cyan}${mark} ${reply.message}${C.reset}`);
+        }
         const line = (isFancy ? "\u2550" : "=").repeat(50);
         const edge = isFancy ? ["\u2554", "\u2551", "\u255A", "\u2557", "\u255D"] : ["+", "|", "+", "+", "+"];
-        const title = success ? `${S.ok} All done` : `${S.warn} Done (with failures)`;
+        const title = reply ? reply.mode === "ask" ? `${S.warn} Needs your input` : `${S.ok} Answered` : success ? `${S.ok} All done` : `${S.warn} Done (with failures)`;
         console.log(`
 ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
         console.log(`${edge[1]}  ${title.padEnd(48)}${edge[1]}`);
@@ -131,9 +543,11 @@ ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
         console.log(`  ~ ${"Total".padEnd(nameWidth)}   ${totalStr.padStart(7)}`);
         for (const r of agentResults) {
           const icon = r.status === "success" ? S.ok : S.fail;
-          const color = r.status === "success" ? C.green : C.red;
+          const color2 = r.status === "success" ? C.green : C.red;
           const dur = `${(r.duration / 1e3).toFixed(1)}s`;
-          console.log(`  ${color}${icon}${C.reset} ${r.agentName.padEnd(nameWidth)}   ${dur.padStart(7)}`);
+          console.log(
+            `  ${color2}${icon}${C.reset} ${r.agentName.padEnd(nameWidth)}   ${dur.padStart(7)}`
+          );
         }
         console.log();
         break;
@@ -143,250 +557,136 @@ ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
 };
 
 // src/reporters/FileLogWriter.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var FileLogWriter = class {
-  constructor(logDir) {
+  constructor(logDir, onError = (message) => process.stderr.write(`
+[multiclaw] ${message}
+`)) {
     this.logDir = logDir;
+    this.onError = onError;
     this.streams = /* @__PURE__ */ new Map();
-    fs2.mkdirSync(logDir, { recursive: true });
+    /** Agent ids whose log could not be opened — never retried, so a broken
+     *  directory does not produce one failing stream per output chunk. */
+    this.failed = /* @__PURE__ */ new Set();
+    fs3.mkdirSync(logDir, { recursive: true });
   }
   attach(eventBus) {
     return eventBus.subscribe((e) => this.handle(e));
   }
+  /**
+   * Flush every open stream.
+   *
+   * `stream.end()` only *starts* the flush, so a caller that exits the moment
+   * `orchestration:complete` arrives can lose the tail of the last agent's log.
+   * Awaiting this is what makes that tail durable.
+   */
+  async drain() {
+    if (!this.closing) this.closing = this.flush();
+    await this.closing;
+  }
   handle(e) {
     if (e.type === "agent:output") {
-      this.getStream(e.payload.agentId).write(e.payload.chunk);
+      this.getStream(e.payload.agentId)?.write(e.payload.chunk);
     }
     if (e.type === "orchestration:complete") {
-      fs2.writeFileSync(
-        path2.join(this.logDir, "report.json"),
-        JSON.stringify(e.payload, null, 2)
-      );
-      this.closeAll();
+      try {
+        fs3.writeFileSync(path3.join(this.logDir, "report.json"), JSON.stringify(e.payload, null, 2));
+      } catch (err) {
+        this.onError(`Could not write report.json: ${errorMessage(err)}`);
+      }
+      this.closing ??= this.flush();
     }
   }
   getStream(agentId) {
-    if (!this.streams.has(agentId)) {
-      this.streams.set(
-        agentId,
-        fs2.createWriteStream(path2.join(this.logDir, `${agentId}.log`))
-      );
+    if (this.failed.has(agentId)) return void 0;
+    let stream = this.streams.get(agentId);
+    if (!stream) {
+      stream = fs3.createWriteStream(path3.join(this.logDir, `${agentId}.log`));
+      stream.on("error", (err) => {
+        this.failed.add(agentId);
+        this.streams.delete(agentId);
+        this.onError(`Could not write ${agentId}.log: ${errorMessage(err)}`);
+      });
+      this.streams.set(agentId, stream);
     }
-    return this.streams.get(agentId);
+    return stream;
   }
-  closeAll() {
-    for (const s of this.streams.values()) s.end();
+  flush() {
+    const streams = [...this.streams.values()];
     this.streams.clear();
+    return Promise.all(
+      streams.map(
+        (s) => new Promise((resolve3) => {
+          if (s.destroyed || s.writableEnded) {
+            resolve3();
+            return;
+          }
+          s.end(() => resolve3());
+        })
+      )
+    ).then(() => void 0);
   }
 };
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // src/commands/run.ts
+var EXIT_CANCELLED = 130;
 async function runCommand(requirement, options) {
   const config = await loadConfig(options.config, requirement);
   if (options.noLeader) {
     config.useLeader = false;
   }
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  config.workDir = path3.join(config.workDir, ".multiclaw", "runs", `run-${ts}`);
-  const runtimeNames = new Set(config.agents.map((a) => a.runtime ?? "claude"));
-  for (const name of runtimeNames) {
-    let rt;
-    try {
-      rt = runtimeRegistry.get(name);
-    } catch {
-      console.error(`\x1B[31mError: Unknown runtime "${name}". Supported: claude\x1B[0m`);
-      process.exit(1);
-    }
-    if (!await rt.checkAvailable()) {
-      console.error(`\x1B[31mError: Runtime "${name}" is not available. Make sure the CLI is installed.\x1B[0m`);
-      process.exit(1);
-    }
-  }
+  config.workDir = path4.join(config.workDir, ".multiclaw", "runs", `run-${ts}`);
+  await assertRuntimesAvailable(config);
   const orchestrator = new OrchestratorImpl(config);
   new ConsoleReporter().attach(orchestrator.eventBus);
-  const logDir = config.logDir ?? path3.join(config.workDir, "logs");
-  new FileLogWriter(logDir).attach(orchestrator.eventBus);
+  const logDir = config.logDir ?? path4.join(config.workDir, "logs");
+  const logs = new FileLogWriter(logDir);
+  logs.attach(orchestrator.eventBus);
   console.log(`\x1B[2mLogs: ${logDir}\x1B[0m`);
-  if (options.ui && options.serverUrl) {
-    console.warn("\x1B[33mWarning: --ui and --server-url cannot be used together. Using --ui.\x1B[0m");
-  }
-  if (options.ui) {
-    await attachDashboard(orchestrator, config, options);
-  } else if (options.serverUrl) {
-    await attachRemoteServer(orchestrator, options.serverUrl);
-  }
-  const result = await orchestrator.run();
-  process.exit(result.success ? 0 : 1);
-}
-async function attachDashboard(orchestrator, config, options) {
-  const { DashboardServer } = await import("@multiclawcli/dashboard/server");
-  const port = options.port ?? config.dashboard?.port ?? 3210;
-  const server = new DashboardServer({ port });
-  await server.start();
-  server.bindEventBus(orchestrator.eventBus);
-  const url = `http://localhost:${port}`;
-  console.log(`\x1B[36mDashboard: ${url}\x1B[0m`);
-  if (config.dashboard?.autoOpen ?? true) {
-    const { default: open } = await import("open");
-    await open(url);
-  }
-}
-async function attachRemoteServer(orchestrator, serverUrl) {
-  const { WebSocket } = await import("ws");
-  const wsUrl = serverUrl.replace(/^https?/, (p) => p === "https" ? "wss" : "ws");
-  const ws = new WebSocket(wsUrl);
-  await new Promise((resolve3, reject) => {
-    const timer = setTimeout(() => reject(new Error(`Connection to serve timed out: ${serverUrl}`)), 5e3);
-    ws.on("open", () => {
-      clearTimeout(timer);
-      resolve3();
-    });
-    ws.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-  console.log(`\x1B[36mConnected to Dashboard server: ${serverUrl}\x1B[0m`);
-  orchestrator.eventBus.subscribe((e) => {
-    if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(e));
-  });
-}
-
-// src/commands/init.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
-import { execSync } from "child_process";
-import { select, input } from "@inquirer/prompts";
-var AGENT_BLOCKS = {
-  simple: `    agents.architect(),
-    agents.archDesignReviewer({ dependsOn: ["architect"] }),
-    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
-    agents.codeReviewer({ dependsOn: ["backend-developer"] }),`,
-  backend: `    agents.productManager(),
-    agents.architect({ dependsOn: ["product-manager"] }),
-    agents.archDesignReviewer({ dependsOn: ["architect"] }),
-    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
-    agents.tester({ dependsOn: ["backend-developer"] }),
-    agents.codeReviewer({ dependsOn: ["tester"] }),
-    agents.devops({ dependsOn: ["tester"] }),`,
-  fullstack: `    agents.productManager(),
-    agents.architect({ dependsOn: ["product-manager"] }),
-    agents.archDesignReviewer({ dependsOn: ["architect"] }),
-    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
-    agents.uiDesigner({ dependsOn: ["arch-design-reviewer"] }),
-    agents.uiDesignReviewer({ dependsOn: ["ui-designer"] }),
-    agents.frontendDeveloper({ dependsOn: ["ui-design-reviewer"] }),
-    agents.codeReviewer({ dependsOn: ["backend-developer", "frontend-developer"] }),
-    agents.devops({ dependsOn: ["backend-developer", "frontend-developer"] }),`
-};
-var PRESET_DESCRIPTIONS = {
-  simple: "Architect \u2192 Arch Design Reviewer \u2192 Backend Developer \u2192 Code Reviewer  (4 agents)",
-  backend: "Product Manager \u2192 Architect \u2192 Arch Design Reviewer \u2192 Backend Developer \u2192 Tester \u2192 Code Reviewer + DevOps  (7 agents)",
-  fullstack: "Product Manager \u2192 Architect \u2192 Arch Design Reviewer \u2192 Backend Developer + UI Designer \u2192 UI Design Reviewer \u2192 Frontend Developer \u2192 Code Reviewer + DevOps  (9 agents)"
-};
-var RUNTIME_INSTALL = {
-  claude: "npm install -g @anthropic-ai/claude-code",
-  codex: "npm install -g @openai/codex",
-  opencode: "npm install -g opencode",
-  cursor: "curl https://cursor.com/install | bash"
-};
-function generateConfig(opts) {
-  return `import { defineConfig, agents } from "multiclaw"
-
-export default defineConfig({
-  name: "${opts.projectName}",
-  workDir: "${opts.workDir}",
-  context: {
-    projectName: "${opts.projectName}",
-  },
-  dashboard: { port: 3210, autoOpen: true },
-  agents: [
-${AGENT_BLOCKS[opts.preset]}
-  ],
-})
-`;
-}
-async function initCommand() {
-  const configPath = path4.resolve(process.cwd(), "multiclaw.config.ts");
-  if (fs3.existsSync(configPath)) {
-    console.error("\x1B[31mError: multiclaw.config.ts already exists\x1B[0m");
-    process.exit(1);
-  }
-  const defaultProjectName = path4.basename(process.cwd());
-  const projectName = await input({
-    message: "Project name:",
-    default: defaultProjectName
-  });
-  const preset = await select({
-    message: "Select a preset:",
-    choices: [
-      { value: "simple", name: `simple     \u2014 ${PRESET_DESCRIPTIONS.simple}` },
-      { value: "backend", name: `backend    \u2014 ${PRESET_DESCRIPTIONS.backend}` },
-      { value: "fullstack", name: `fullstack  \u2014 ${PRESET_DESCRIPTIONS.fullstack}` }
-    ]
-  });
-  const workDir = await input({
-    message: "Work directory (where agents read and write files):",
-    default: "."
-  });
+  const controller = new AbortController();
+  const onSigint = () => {
+    if (controller.signal.aborted) process.exit(EXIT_CANCELLED);
+    controller.abort();
+  };
+  process.on("SIGINT", onSigint);
   try {
-    fs3.writeFileSync(configPath, generateConfig({ preset, workDir, projectName }));
-    if (workDir !== ".") {
-      fs3.mkdirSync(path4.resolve(process.cwd(), workDir), { recursive: true });
-    }
-  } catch (err) {
-    console.error(`\x1B[31mError: Failed to create files: ${err.message}\x1B[0m`);
-    process.exit(1);
+    const result = await orchestrator.run({ signal: controller.signal });
+    await logs.drain();
+    process.exitCode = result.cancelled ? EXIT_CANCELLED : result.success ? 0 : 1;
+  } finally {
+    process.off("SIGINT", onSigint);
   }
-  console.log("");
-  console.log(`\x1B[32m\u2713\x1B[0m Created multiclaw.config.ts`);
-  console.log(`  preset:   ${preset}  (${PRESET_DESCRIPTIONS[preset]})`);
-  console.log(`  workDir:  ${workDir}`);
-  console.log("");
-  console.log(`> Run: multiclaw run "describe your requirement" --ui`);
-  checkRuntime();
 }
-function checkRuntime() {
-  const runtimes = ["claude", "codex", "opencode"];
-  const available = runtimes.filter((r) => {
-    try {
-      execSync(`${r} --version`, { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
+
+// src/commands/tui.ts
+async function tuiCommand(options) {
+  const config = await loadConfig(options.config);
+  await assertRuntimesAvailable(config);
+  const { startTui } = await import("@multiclawcli/dashboard/tui");
+  await startTui({
+    config,
+    onTurnStart: (eventBus, logDir) => {
+      new FileLogWriter(logDir).attach(eventBus);
     }
   });
-  if (available.length === 0) {
-    console.log("");
-    console.log("\x1B[33mWarning: No AI runtime detected. Install at least one:\x1B[0m");
-    for (const [name, cmd] of Object.entries(RUNTIME_INSTALL)) {
-      console.log(`  \x1B[2m${name.padEnd(12)} ${cmd}\x1B[0m`);
-    }
-  }
-}
-
-// src/commands/serve.ts
-async function serveCommand(options) {
-  const { DashboardServer } = await import("@multiclawcli/dashboard/server");
-  const port = options.port ?? 3210;
-  const server = new DashboardServer({ port, acceptClientEvents: true });
-  await server.start();
-  console.log(`\x1B[36mDashboard running at: http://localhost:${port}\x1B[0m`);
-  console.log(`  In another terminal run: multiclaw run "<requirement>" --server-url http://localhost:${port}`);
 }
 
 // src/commands/upgrade.ts
-import { execSync as execSync2 } from "child_process";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
+import { execSync } from "child_process";
+import { createRequire as createRequire2 } from "module";
+var require2 = createRequire2(import.meta.url);
 async function upgradeCommand() {
-  const { version: currentVersion } = require2("../../package.json");
+  const { version: currentVersion } = require2("../package.json");
   console.log(`Current version: v${currentVersion}`);
   console.log("Checking for updates...");
   let latestVersion;
   try {
-    latestVersion = execSync2("npm show multiclaw version", { encoding: "utf8" }).trim();
+    latestVersion = execSync("npm show multiclaw version", { encoding: "utf8" }).trim();
   } catch {
     console.error("\x1B[31mError: Failed to fetch latest version from npm registry\x1B[0m");
     process.exit(1);
@@ -398,10 +698,12 @@ async function upgradeCommand() {
   }
   console.log(`Upgrading multiclaw v${currentVersion} \u2192 v${latestVersion}...`);
   try {
-    execSync2("npm install -g multiclaw@latest", { stdio: "inherit" });
+    execSync("npm install -g multiclaw@latest", { stdio: "inherit" });
     console.log(`\x1B[32m\u2713\x1B[0m Successfully upgraded to v${latestVersion}`);
   } catch {
-    console.error("\x1B[31mError: Upgrade failed. Try running manually: npm install -g multiclaw@latest\x1B[0m");
+    console.error(
+      "\x1B[31mError: Upgrade failed. Try running manually: npm install -g multiclaw@latest\x1B[0m"
+    );
     process.exit(1);
   }
 }
@@ -411,12 +713,13 @@ var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 var pkg = JSON.parse(readFileSync(join3(__dirname2, "../package.json"), "utf-8"));
 var program = new Command();
-program.name("multiclaw").description("Multi-agent orchestration CLI").version(pkg.version, "-v, --version", "Display version number");
+program.name("multiclaw").description("Multi-agent orchestration CLI").version(pkg.version, "-v, --version", "Display version number").action((options) => tuiCommand(options));
 program.command("init").description("Scaffold a config file (interactive)").action(() => initCommand());
-program.command("run <requirement>").description("Run an orchestration").option("--config <path>", "Config file path (default: auto-discover ./multiclaw.config.ts)").option("--ui", "Start Dashboard and open in browser").option("--port <port>", "Dashboard port (requires --ui)", (v) => parseInt(v, 10)).option("--server-url <url>", "Connect to a running serve process").option("--no-leader", "Skip the leader agent and use the default pipeline").action((requirement, opts) => runCommand(requirement, opts));
-program.command("serve").description("Start a persistent Dashboard server").option("--port <port>", "Port", (v) => parseInt(v, 10)).action((opts) => serveCommand(opts));
+program.command("run <requirement>").description("Run an orchestration headlessly").option("--config <path>", "Config file path (default: auto-discover ./multiclaw.config.ts)").option("--no-leader", "Batch mode only: skip routing and run the full team").action((requirement, opts) => runCommand(requirement, opts));
 program.command("upgrade").description("Upgrade multiclaw to the latest version").action(() => upgradeCommand());
+program.command("doctor").description("Check which agent providers are installed and ready").option("--config <path>", "Config file path (default: auto-discover ./multiclaw.config.ts)").action((opts) => doctorCommand(opts.config));
 program.parseAsync(process.argv).catch((err) => {
-  console.error(`\x1B[31mError: ${err.message ?? err}\x1B[0m`);
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`\x1B[31mError: ${message}\x1B[0m`);
   process.exit(1);
 });