multiclaw 0.3.2 → 0.5.0

package/dist/index.js

@@ -1,19 +1,27 @@
 #!/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 { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join4 } 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,
+  resolveCommand,
+  resolveProvider,
+  specForCommand,
+  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 +32,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")
+    );
+  }
+}
+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;
   }
-  const config = mod.default ?? mod.config;
+  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 +88,431 @@ 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,
+      source: d.source,
+      resolvedPath: d.resolvedPath,
+      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);
+    const agentsWithUnsupportedTools = agents2.map((a) => {
+      const command = resolveCommand(a, config);
+      const spec = specForCommand(command) ?? specForProvider(resolveProvider(a, config));
+      return { id: a.id, spec, tools: a.tools };
+    }).filter((a) => a.spec && !a.spec.tools && a.tools !== void 0).map((a) => a.id);
+    configReport = {
+      name: config.name,
+      defaultsProvider,
+      defaultsProviderOk,
+      agentsWithMissingProvider,
+      agentsWithUnsupportedTools
+    };
+  }
+  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)}${cell("source", 9)}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 source = p.source ?? "\u2014";
+    const sourceCode = p.source === "bundled" ? YELLOW : void 0;
+    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(source, 9, sourceCode)}${cell(models, 7)}${auth}`
+    );
+    if (p.status === "present" && p.source === "bundled" && p.resolvedPath) {
+      lines.push(c(DIM, `    bundled bridge: ${p.resolvedPath}`));
+    }
+    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"));
+    }
+    if (report.config.agentsWithUnsupportedTools.length > 0) {
+      lines.push(
+        c(
+          YELLOW,
+          `  ${report.config.agentsWithUnsupportedTools.length} agent(s) use a provider that cannot enforce tool allowlists: ${report.config.agentsWithUnsupportedTools.join(", ")}`
+        )
+      );
+    }
+  }
+  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)"
+};
+var PRESET_AGENT_IDS = {
+  backend: [
+    "productManager",
+    "architect",
+    "archDesignReviewer",
+    "backendDeveloper",
+    "tester",
+    "codeReviewer",
+    "devops"
+  ],
+  frontend: [
+    "architect",
+    "uiDesigner",
+    "uiDesignReviewer",
+    "frontendDeveloper",
+    "tester",
+    "codeReviewer"
+  ],
+  fullstack: [
+    "productManager",
+    "architect",
+    "archDesignReviewer",
+    "backendDeveloper",
+    "uiDesigner",
+    "uiDesignReviewer",
+    "frontendDeveloper",
+    "tester",
+    "codeReviewer",
+    "devops"
+  ]
+};
+var OVERRIDE_LABELS = {
+  leader: "\u2605 Leader",
+  productManager: "Product Manager",
+  architect: "Architect",
+  archDesignReviewer: "Arch Design Reviewer",
+  backendDeveloper: "Backend Developer",
+  frontendDeveloper: "Frontend Developer",
+  uiDesigner: "UI Designer",
+  uiDesignReviewer: "UI Design Reviewer",
+  tester: "Tester",
+  codeReviewer: "Code Reviewer",
+  devops: "DevOps"
+};
+function overrideChoices(preset) {
+  const ids = PRESET_AGENT_IDS[preset] ?? [];
+  return [
+    { value: "leader", name: OVERRIDE_LABELS.leader },
+    ...ids.map((id) => ({ value: id, name: OVERRIDE_LABELS[id] ?? id }))
+  ];
+}
+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)}`);
+  const leaderOverride = opts.overrides?.find((o) => o.id === "leader");
+  const leaderLine = leaderOverride ? `  leader: agents.leader({ model: ${JSON.stringify(leaderOverride.model)} }),` : `  leader: agents.leader(),`;
+  let agentBlock = AGENT_BLOCKS[opts.preset];
+  if (opts.overrides && opts.overrides.length > 0) {
+    for (const ov of opts.overrides) {
+      const id = ov.id;
+      if (id === "leader") continue;
+      const model = JSON.stringify(ov.model);
+      const re = new RegExp(`(agents\\.${id}\\([^)]*\\))`, "g");
+      agentBlock = agentBlock.replace(re, (match) => {
+        const body = match.slice(id.length + 8, -1).trim().replace(/^\{/, "").replace(/\}$/, "").trim();
+        const sep = body ? ", " : "";
+        return `agents.${id}({ ${body}${sep}model: ${model} })`;
+      });
+    }
+  }
+  return `import { defineConfig, agents } from "multiclaw"
+
+export default defineConfig({
+  name: ${name},
+  workDir: ${workDir},
+${leaderLine}
+  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: overrideChoices(preset)
+  });
+  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 fs5 from "fs";
+import * as path5 from "path";
+import {
+  describeResumePlan,
+  Orchestrator as OrchestratorImpl
+} from "@multiclawcli/core";
+
+// src/lib.ts
+import {
+  detectProviders as detectProviders3,
+  presentProviders as presentProviders2,
+  resolveCommand as resolveCommand2,
+  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 = resolveCommand2(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: "*" };
@@ -70,6 +535,11 @@ var C = isFancy ? {
   red: "",
   purple: ""
 };
+function markFor(status) {
+  if (status === "success") return { icon: S.ok, color: C.green };
+  if (status === "cancelled") return { icon: S.skip, color: C.yellow };
+  return { icon: S.fail, color: C.red };
+}
 var ConsoleReporter = class {
   attach(eventBus) {
     return eventBus.subscribe((e) => this.handle(e));
@@ -83,8 +553,20 @@ 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}
+`
+        );
+        if (e.payload.selectionReason) {
+          console.log(`${C.dim}${S.bullet} Why: ${e.payload.selectionReason}${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": {
@@ -97,6 +579,7 @@ ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
         break;
       }
       case "agent:output": {
+        if (e.payload.kind && e.payload.kind !== "text") break;
         process.stdout.write(`  ${e.payload.chunk}`);
         break;
       }
@@ -106,6 +589,10 @@ ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
         break;
       }
       case "agent:failed": {
+        if (e.payload.status === "cancelled") {
+          console.log(`${C.yellow}${S.skip} ${e.payload.agentName} cancelled${C.reset}`);
+          break;
+        }
         console.log(`${C.red}${S.fail} ${e.payload.agentName} failed: ${e.payload.error}${C.reset}`);
         break;
       }
@@ -114,26 +601,50 @@ ${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` : e.payload.cancelled ? `${S.skip} Cancelled` : 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]}`);
         console.log(`${edge[2]}${line}${edge[4]}${C.reset}`);
         const nameWidth = Math.max(8, ...agentResults.map((r) => r.agentName.length));
         const totalStr = `${(totalDuration / 1e3).toFixed(1)}s`;
-        console.log(`  ~ ${"Total".padEnd(nameWidth)}   ${totalStr.padStart(7)}`);
+        const cost = e.payload.totalCostUsd;
+        const costStr = cost === void 0 ? "" : `  $${cost.toFixed(2)}`;
+        console.log(`  ~ ${"Total".padEnd(nameWidth)}   ${totalStr.padStart(7)}${costStr}`);
         for (const r of agentResults) {
-          const icon = r.status === "success" ? S.ok : S.fail;
-          const color = r.status === "success" ? C.green : C.red;
+          const { icon, color: color2 } = markFor(r.status);
           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)}`
+          );
+        }
+        if (e.payload.deliverables && e.payload.deliverables.length > 0) {
+          console.log(`
+  Deliverables:`);
+          for (const file of e.payload.deliverables.slice(0, 5)) {
+            console.log(`  ${S.bullet} ${file.path} (${file.status}, ${file.size} bytes)`);
+          }
+          if (e.payload.deliverables.length > 5) {
+            console.log(`  ${S.bullet} \u2026 ${e.payload.deliverables.length - 5} more`);
+          }
         }
         console.log();
         break;
@@ -143,250 +654,280 @@ ${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);
+      const { agentId, chunk, kind } = e.payload;
+      if (kind && kind !== "text") return;
+      this.getStream(agentId)?.write(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((resolve4) => {
+          if (s.destroyed || s.writableEnded) {
+            resolve4();
+            return;
+          }
+          s.end(() => resolve4());
+        })
+      )
+    ).then(() => void 0);
   }
 };
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/commands/resume.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function resolveRunDir(runsRoot, target) {
+  if (typeof target !== "string" || target === "latest") {
+    return latestRunDir(runsRoot);
+  }
+  const resolved = path4.resolve(target);
+  const runDir = path4.basename(resolved) === "logs" ? path4.dirname(resolved) : resolved;
+  if (!fs4.existsSync(runDir)) {
+    throw new Error(`Run directory not found: ${runDir}`);
+  }
+  return runDir;
+}
+function latestRunDir(runsRoot) {
+  const names = fs4.existsSync(runsRoot) ? fs4.readdirSync(runsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")).map((entry) => entry.name).sort() : [];
+  const latest = names[names.length - 1];
+  if (!latest) {
+    throw new Error(`No runs found to resume \u2014 looked in ${runsRoot}`);
+  }
+  return path4.join(runsRoot, latest);
+}
+function readReport(runDir) {
+  const reportPath = path4.join(runDir, "logs", "report.json");
+  let raw;
+  try {
+    raw = fs4.readFileSync(reportPath, "utf-8");
+  } catch {
+    throw new Error(`No report.json in ${runDir} \u2014 it may not be a complete run`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`Could not parse ${reportPath}: ${detail}`);
+  }
+}
+function resumeOptionsFromReport(report, requirementOverride) {
+  const agents2 = [...new Set(report.agentResults.map((result) => result.agentId))];
+  if (agents2.length === 0) {
+    throw new Error("The previous run has no agent results \u2014 nothing to resume");
+  }
+  const sessions = {};
+  for (const result of report.agentResults) {
+    if (result.sessionId) sessions[result.agentId] = result.sessionId;
+  }
+  const requirement = requirementOverride ?? report.requirement;
+  if (requirement === void 0) {
+    throw new Error("The previous run recorded no requirement \u2014 pass one explicitly to resume");
+  }
+  return {
+    requirement,
+    resume: {
+      agents: agents2,
+      // Absent, not `{}`: core reads a missing `sessions` as "start every agent
+      // fresh", which is exactly the single-agent retry of a failed agent.
+      ...Object.keys(sessions).length > 0 ? { sessions } : {}
+    }
+  };
+}
 
 // src/commands/run.ts
-async function runCommand(requirement, options) {
-  const config = await loadConfig(options.config, requirement);
+var EXIT_CANCELLED = 130;
+async function runCommand(requirementArg, options) {
+  const config = await loadConfig(options.config, requirementArg);
   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);
-    }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  if (options.resume !== void 0) {
+    const runsRoot = path5.join(config.workDir, ".multiclaw", "runs");
+    const runDir = resolveRunDir(runsRoot, options.resume);
+    const report = readReport(runDir);
+    const { requirement, resume } = resumeOptionsFromReport(report, requirementArg);
+    config.workDir = runDir;
+    config.resume = resume;
+    config.context = { ...config.context, requirement };
+    config.logDir = path5.join(runDir, `logs-resume-${stamp}`);
+    const plan = describeResumePlan({
+      agents: resume.agents,
+      sessions: resume.sessions,
+      team: config.agents
+    });
+    console.log(`\x1B[2mResuming ${runDir} (${resume.agents.length} agents) \u2014 ${plan}\x1B[0m`);
+  } else {
+    config.workDir = path5.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`);
+  }
+  if (options.dryRun) {
+    const preview = await new OrchestratorImpl(config).preview();
+    printDryRun(preview, config.workDir);
+    process.exitCode = 0;
+    return;
   }
+  await assertRuntimesAvailable(config);
+  const before = snapshotFiles(config.workDir);
   const orchestrator = new OrchestratorImpl(config);
+  orchestrator.eventBus.subscribe((event) => {
+    if (event.type !== "orchestration:complete") return;
+    event.payload.deliverables = collectDeliverables(config.workDir, before);
+  });
   new ConsoleReporter().attach(orchestrator.eventBus);
-  const logDir = config.logDir ?? path3.join(config.workDir, "logs");
-  new FileLogWriter(logDir).attach(orchestrator.eventBus);
+  const logDir = config.logDir ?? path5.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 controller = new AbortController();
+  const onSigint = () => {
+    if (controller.signal.aborted) process.exit(EXIT_CANCELLED);
+    controller.abort();
+  };
+  process.on("SIGINT", onSigint);
+  try {
+    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);
   }
-  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);
+function printDryRun(preview, workDir) {
+  console.log("Dry run \u2014 no pipeline agents will execute.");
+  console.log(`Project: ${preview.name}`);
+  console.log(`Work dir: ${workDir}`);
+  if (preview.requirement) console.log(`Requirement: ${preview.requirement}`);
+  if (preview.reply) {
+    console.log(`${preview.reply.mode === "ask" ? "Question" : "Reply"}: ${preview.reply.message}`);
+    return;
+  }
+  console.log(`Agents: ${preview.totalAgents}`);
+  if (preview.selectionReason) console.log(`Why: ${preview.selectionReason}`);
+  for (const stage of preview.stages) {
+    const agents2 = stage.agents.map(
+      (agent) => `${agent.id}${agent.model ? ` (${agent.model})` : ""}`
+    );
+    console.log(`Stage ${stage.stageIndex + 1}: ${agents2.join(", ") || "\u2014"}`);
   }
 }
-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));
+function snapshotFiles(root) {
+  const snapshot = /* @__PURE__ */ new Map();
+  walkFiles(root, (_absolute, relative2, stat) => {
+    snapshot.set(relative2, { mtimeMs: stat.mtimeMs, size: stat.size });
   });
+  return snapshot;
 }
-
-// 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: "."
+function collectDeliverables(root, before) {
+  const deliverables = [];
+  walkFiles(root, (_absolute, relative2, stat) => {
+    const previous = before.get(relative2);
+    if (previous && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size) return;
+    deliverables.push({
+      path: relative2,
+      status: previous ? "modified" : "created",
+      size: stat.size,
+      modifiedAt: stat.mtime.toISOString()
+    });
   });
-  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);
-  }
-  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();
+  return deliverables.sort((a, b) => a.path.localeCompare(b.path)).slice(0, 20);
 }
-function checkRuntime() {
-  const runtimes = ["claude", "codex", "opencode"];
-  const available = runtimes.filter((r) => {
-    try {
-      execSync(`${r} --version`, { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  });
-  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`);
+function walkFiles(root, visit) {
+  if (!fs5.existsSync(root)) return;
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const name of fs5.readdirSync(dir)) {
+      if (name === ".multiclaw") continue;
+      const absolute = path5.join(dir, name);
+      const stat = fs5.statSync(absolute);
+      if (stat.isDirectory()) stack.push(absolute);
+      else if (stat.isFile()) visit(absolute, path5.relative(root, absolute), stat);
     }
   }
 }
 
-// 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/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);
+    }
+  });
 }
 
 // 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");
   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,25 +939,31 @@ 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);
   }
 }
 
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname2(__filename2);
-var pkg = JSON.parse(readFileSync(join3(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = dirname3(__filename2);
+var pkg = JSON.parse(readFileSync2(join4(__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").option("--dry-run", "Preview the routed plan without running the pipeline").option(
+  "--resume [path]",
+  "Resume a previous run, continuing agent sessions (default: the latest)"
+).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);
 });