multiclaw 0.5.0 → 0.6.0

package/dist/commands/run.d.ts

@@ -1,5 +1,6 @@
 export interface RunOptions {
     config?: string;
+    leader?: boolean;
     noLeader?: boolean;
     /**
      * `true` for a bare `--resume` (latest run), or a path to a specific run.

package/dist/commands/tui.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/upgrade.d.ts

@@ -1 +1,30 @@
+/** Which package manager owns the copy of multiclaw that is currently running. */
+export type Installer = "npm" | "pnpm" | "bun" | "yarn" | "unknown";
+/** Walk up from `start` to the package.json that declares this package. */
+export declare function findPackageRoot(start: string): string | undefined;
+/** Read the installed version straight from disk (no module cache to go stale). */
+export declare function readInstalledVersion(pkgRoot: string): string | undefined;
+/**
+ * Identify the installer from the on-disk location of the running package.
+ *
+ * This is the whole point of the command: `npm install -g` writes to npm's
+ * prefix, which is not necessarily where the binary on PATH came from. A user
+ * with a pnpm global install used to get a silent no-op upgrade — npm installed
+ * a fresh copy somewhere else while `multiclaw --version` kept reporting the
+ * pnpm one. Upgrading must therefore target the manager that owns this copy.
+ */
+export declare function detectInstaller(pkgRoot: string): Installer;
+type Exec = (command: string, mode: "capture" | "inherit") => string;
+export interface UpgradeContext {
+    pkgRoot: string;
+    currentVersion: string;
+    installer: Installer;
+    /** Re-read after installing: the on-disk copy is what `--version` reports. */
+    readVersion: (pkgRoot: string) => string | undefined;
+    exec: Exec;
+}
+/** Resolve the running install. `undefined` means it is not an installed copy. */
+export declare function createUpgradeContext(): UpgradeContext | undefined;
+export declare function runUpgrade(ctx: UpgradeContext): Promise<void>;
 export declare function upgradeCommand(): Promise<void>;
+export {};

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 
 // src/commands/doctor.ts
@@ -611,7 +611,7 @@ ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
         break;
       }
       case "orchestration:complete": {
-        const { success, totalDuration, agentResults, reply } = e.payload;
+        const { success, totalDuration, agentResults, reply, acceptance } = e.payload;
         if (reply) {
           const mark = reply.mode === "ask" ? "?" : S.ok;
           console.log(`
@@ -619,11 +619,22 @@ ${C.cyan}${mark} ${reply.message}${C.reset}`);
         }
         const line = (isFancy ? "\u2550" : "=").repeat(50);
         const edge = isFancy ? ["\u2554", "\u2551", "\u255A", "\u2557", "\u255D"] : ["+", "|", "+", "+", "+"];
-        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)`;
+        const title = reply ? reply.mode === "ask" ? `${S.warn} Needs your input` : `${S.ok} Answered` : acceptance ? acceptance.status === "approved" ? `${S.ok} Approved` : acceptance.status === "changes_required" ? `${S.warn} Changes required` : acceptance.status === "cancelled" ? `${S.skip} Acceptance cancelled` : `${S.fail} Acceptance failed` : 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}`);
+        if (acceptance) {
+          console.log(
+            `  Reviewer: ${acceptance.reviewer}  Repair rounds: ${acceptance.repairRounds}`
+          );
+          if (acceptance.reason) console.log(`  ${acceptance.reason}`);
+          const review = acceptance.reviews[acceptance.reviews.length - 1];
+          if (review) {
+            console.log(`  ${review.summary}`);
+            for (const issue of review.issues) console.log(`  ${S.bullet} ${issue}`);
+          }
+        }
         const nameWidth = Math.max(8, ...agentResults.map((r) => r.agentName.length));
         const totalStr = `${(totalDuration / 1e3).toFixed(1)}s`;
         const cost = e.payload.totalCostUsd;
@@ -716,12 +727,12 @@ var FileLogWriter = class {
     this.streams.clear();
     return Promise.all(
       streams.map(
-        (s) => new Promise((resolve4) => {
+        (s) => new Promise((resolve5) => {
           if (s.destroyed || s.writableEnded) {
-            resolve4();
+            resolve5();
             return;
           }
-          s.end(() => resolve4());
+          s.end(() => resolve5());
         })
       )
     ).then(() => void 0);
@@ -769,12 +780,13 @@ function readReport(runDir) {
   }
 }
 function resumeOptionsFromReport(report, requirementOverride) {
-  const agents2 = [...new Set(report.agentResults.map((result) => result.agentId))];
+  const latest = new Map(report.agentResults.map((result) => [result.agentId, result]));
+  const agents2 = [...latest.keys()].filter((id) => id !== report.acceptance?.reviewer);
   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) {
+  for (const result of latest.values()) {
     if (result.sessionId) sessions[result.agentId] = result.sessionId;
   }
   const requirement = requirementOverride ?? report.requirement;
@@ -796,7 +808,7 @@ function resumeOptionsFromReport(report, requirementOverride) {
 var EXIT_CANCELLED = 130;
 async function runCommand(requirementArg, options) {
   const config = await loadConfig(options.config, requirementArg);
-  if (options.noLeader) {
+  if (options.leader === false || options.noLeader) {
     config.useLeader = false;
   }
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
@@ -912,47 +924,147 @@ async function tuiCommand(options) {
   await startTui({
     config,
     onTurnStart: (eventBus, logDir) => {
-      new FileLogWriter(logDir).attach(eventBus);
+      const writer = new FileLogWriter(logDir);
+      const detach = writer.attach(eventBus);
+      return async () => {
+        try {
+          await writer.drain();
+        } finally {
+          detach();
+        }
+      };
     }
   });
 }
 
 // src/commands/upgrade.ts
 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}`);
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "multiclaw";
+var RED2 = "\x1B[31m";
+var GREEN2 = "\x1B[32m";
+var RESET2 = "\x1B[0m";
+function readManifest(dir) {
+  const manifest = join4(dir, "package.json");
+  if (!existsSync5(manifest)) return void 0;
+  try {
+    return JSON.parse(readFileSync2(manifest, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function findPackageRoot(start) {
+  let dir = resolve4(start);
+  for (; ; ) {
+    if (readManifest(dir)?.name === PACKAGE_NAME) return dir;
+    const parent = dirname3(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readInstalledVersion(pkgRoot) {
+  return readManifest(pkgRoot)?.version;
+}
+function detectInstaller(pkgRoot) {
+  const path6 = pkgRoot.replaceAll("\\", "/");
+  if (path6.includes("/pnpm/global/") || path6.includes("/.pnpm/")) return "pnpm";
+  if (path6.includes("/install/global/") || path6.includes("/.bun/")) return "bun";
+  if (path6.includes("/yarn/global/")) return "yarn";
+  if (path6.includes("/node_modules/")) return "npm";
+  return "unknown";
+}
+var COMMANDS = {
+  npm: { latest: "npm show multiclaw version", install: "npm install -g multiclaw@latest" },
+  pnpm: { latest: "pnpm view multiclaw version", install: "pnpm add -g multiclaw@latest" },
+  bun: void 0,
+  yarn: void 0,
+  unknown: void 0
+};
+var MANUAL = {
+  npm: "npm install -g multiclaw@latest",
+  pnpm: "pnpm add -g multiclaw@latest",
+  bun: "bun add -g multiclaw@latest",
+  yarn: "yarn global add multiclaw@latest",
+  unknown: "npm install -g multiclaw@latest"
+};
+function createUpgradeContext() {
+  const pkgRoot = findPackageRoot(dirname3(fileURLToPath(import.meta.url)));
+  if (!pkgRoot) return void 0;
+  const currentVersion = readInstalledVersion(pkgRoot);
+  if (!currentVersion) return void 0;
+  return {
+    pkgRoot,
+    currentVersion,
+    installer: detectInstaller(pkgRoot),
+    readVersion: readInstalledVersion,
+    exec: (command, mode) => {
+      if (mode === "inherit") {
+        execSync(command, { stdio: "inherit" });
+        return "";
+      }
+      return execSync(command, { encoding: "utf8" });
+    }
+  };
+}
+async function runUpgrade(ctx) {
+  const { pkgRoot, currentVersion, installer, exec, readVersion } = ctx;
+  console.log(`Current version: v${currentVersion} (${installer} install)`);
+  const commands = COMMANDS[installer];
+  if (!commands) {
+    const reason = installer === "unknown" ? `this copy is not a global install (${pkgRoot})` : `the ${installer} install at ${pkgRoot} cannot be upgraded automatically`;
+    console.error(`${RED2}Error: ${reason}. Run it manually: ${MANUAL[installer]}${RESET2}`);
+    process.exit(1);
+    return;
+  }
   console.log("Checking for updates...");
   let latestVersion;
   try {
-    latestVersion = execSync("npm show multiclaw version", { encoding: "utf8" }).trim();
+    latestVersion = exec(commands.latest, "capture").trim();
   } catch {
-    console.error("\x1B[31mError: Failed to fetch latest version from npm registry\x1B[0m");
+    console.error(`${RED2}Error: Failed to fetch latest version from npm registry${RESET2}`);
     process.exit(1);
     return;
   }
   if (latestVersion === currentVersion) {
-    console.log(`\x1B[32m\u2713\x1B[0m Already on the latest version (v${currentVersion})`);
+    console.log(`${GREEN2}\u2713${RESET2} Already on the latest version (v${currentVersion})`);
     return;
   }
   console.log(`Upgrading multiclaw v${currentVersion} \u2192 v${latestVersion}...`);
   try {
-    execSync("npm install -g multiclaw@latest", { stdio: "inherit" });
-    console.log(`\x1B[32m\u2713\x1B[0m Successfully upgraded to v${latestVersion}`);
+    exec(commands.install, "inherit");
   } catch {
+    console.error(`${RED2}Error: Upgrade failed. Try running manually: ${commands.install}${RESET2}`);
+    process.exit(1);
+    return;
+  }
+  const installedVersion = readVersion(pkgRoot);
+  if (installedVersion !== latestVersion) {
     console.error(
-      "\x1B[31mError: Upgrade failed. Try running manually: npm install -g multiclaw@latest\x1B[0m"
+      `${RED2}Error: ${commands.install} finished, but ${pkgRoot} still reports v${installedVersion ?? "unknown"}. Check for a second multiclaw install, then retry.${RESET2}`
     );
     process.exit(1);
+    return;
+  }
+  console.log(`${GREEN2}\u2713${RESET2} Successfully upgraded to v${latestVersion} (${pkgRoot})`);
+}
+async function upgradeCommand() {
+  const ctx = createUpgradeContext();
+  if (!ctx) {
+    console.error(
+      `${RED2}Error: could not locate the multiclaw package this process is running from.${RESET2}`
+    );
+    process.exit(1);
+    return;
   }
+  await runUpgrade(ctx);
 }
 
 // src/index.ts
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname3(__filename2);
-var pkg = JSON.parse(readFileSync2(join4(__dirname2, "../package.json"), "utf-8"));
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname4(__filename2);
+var pkg = JSON.parse(readFileSync3(join5(__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").action((options) => tuiCommand(options));
 program.command("init").description("Scaffold a config file (interactive)").action(() => initCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaw",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "bin": {
     "multiclaw": "dist/index.js"
@@ -27,11 +27,11 @@
     "url": "https://github.com/shipengqi/multiclaw/issues"
   },
   "dependencies": {
-    "@agentclientprotocol/claude-agent-acp": "^0.93.0",
+    "@agentclientprotocol/claude-agent-acp": "^0.95.0",
     "@agentclientprotocol/codex-acp": "^2.2.2",
-    "@inquirer/prompts": "^8.7.3",
-    "@multiclawcli/core": "0.5.0",
-    "@multiclawcli/dashboard": "0.5.0",
+    "@inquirer/prompts": "^8.7.4",
+    "@multiclawcli/core": "0.6.0",
+    "@multiclawcli/dashboard": "0.6.0",
     "commander": "^15.0.0",
     "jiti": "^2.7.0"
   },