@konglx/rotom 2.21.0

package/dist/cli/group.js

@@ -0,0 +1,273 @@
+/**
+ * rotom group — group create/list/members/history/send/upload/archive/unarchive.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { api, printJson, printTable, isPretty, fail, flagInt, flagStr, requireFlag, } from "./common.js";
+import { route, qs, usage, unknownSubcommand } from "./routes.js";
+// Minimal MIME sniff table — keep it inline; we accept only the 4 formats the
+// uploads endpoint allowlists. Anything else is an error before we hit network.
+const EXT_TO_MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+};
+function guessMime(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return EXT_TO_MIME[ext] ?? null;
+}
+export async function cmdGroup(agent, rest, flags) {
+    const sub = rest[0];
+    if (sub === "create") {
+        const title = rest[1];
+        if (!title)
+            usage("group create", "<title> --agents <a,b[,c...]> [--message M] [--note D] [--note-file F] [--cwd PATH] [--no-template] [--a2a-direct]");
+        const agentsFlag = requireFlag(flags, "agents");
+        const agents = agentsFlag.split(",").map((s) => s.trim()).filter(Boolean);
+        if (agents.length === 0)
+            fail("--agents must list at least one agent name (comma-separated)");
+        const message = flagStr(flags, "message");
+        const noteInline = flagStr(flags, "note");
+        const noteFile = flagStr(flags, "note-file");
+        if (noteInline && noteFile)
+            fail("--note and --note-file are mutually exclusive");
+        const cwd = flagStr(flags, "cwd");
+        const noTemplate = flags["no-template"] === true;
+        const a2aDirect = flags["a2a-direct"] === true;
+        // 单播群(unicast):消息不广播、worker 不被消息自动唤醒,只通过 CLI --need-reply
+        // 显式点名叫醒对方。≥2 成员,后续可追加。
+        if (a2aDirect && agents.length < 2) {
+            fail("单播群(--a2a-direct)至少需要 2 个成员: rotom group create <title> --agents a,b[,c...] --a2a-direct");
+        }
+        if (a2aDirect && new Set(agents).size !== agents.length) {
+            fail("单播群(--a2a-direct)成员不能重复");
+        }
+        // 预检:校验 --agents 名字都已注册,未注册 → fail 不建群
+        const allAgents = await api(agent, "GET", "/agents");
+        const knownNames = new Set(allAgents.map((a) => a.name));
+        const unknown = agents.filter((n) => !knownNames.has(n));
+        if (unknown.length > 0) {
+            fail(`--agents contains unregistered name(s): ${unknown.join(", ")}\n` +
+                `  注册过的 agent 见 \`rotom directory\`。建群中止,未产生任何副作用。`);
+        }
+        // 建群 + 拉人(一次 API 调用,master 内部 addGroupMembers)
+        const createBody = { name: title, memberNames: agents };
+        if (cwd)
+            createBody.workingDir = cwd;
+        if (a2aDirect)
+            createBody.type = "a2a_direct";
+        const created = await api(agent, "POST", "/groups", createBody);
+        const groupId = created.id;
+        // 默认加载"群内讨论方案设计" guidance template
+        let guidanceTemplate = null;
+        if (!noTemplate) {
+            try {
+                const templates = await api(agent, "GET", "/guidance-templates");
+                const tpl = templates.find((t) => t.name === "群内讨论方案设计");
+                if (tpl?.prompt_text) {
+                    await api(agent, "PATCH", route("/groups/:groupId", groupId), { guidancePrompt: tpl.prompt_text });
+                    guidanceTemplate = tpl.name;
+                }
+                else {
+                    process.stderr.write(`[rotom] warn: guidance template "群内讨论方案设计" not found on master, skip (group still created)\n`);
+                }
+            }
+            catch (e) {
+                process.stderr.write(`[rotom] warn: failed to load guidance template: ${e.message} (group still created)\n`);
+            }
+        }
+        // 可选:建群即发开场消息
+        let messagePosted = false;
+        if (message) {
+            await api(agent, "POST", route("/cli/groups/:groupId/send", groupId), { target: "全体", message });
+            messagePosted = true;
+        }
+        // 可选:建群即建 note
+        let noteId;
+        if (noteInline || noteFile) {
+            let noteDescription = "";
+            if (noteFile) {
+                const expanded = noteFile.startsWith("~/") ? path.join(process.env.HOME || "", noteFile.slice(2)) : noteFile;
+                if (!fs.existsSync(expanded))
+                    fail(`--note-file not found: ${expanded}`);
+                noteDescription = fs.readFileSync(expanded, "utf-8");
+            }
+            else if (noteInline) {
+                noteDescription = noteInline;
+            }
+            const noteRes = await api(agent, "POST", route("/groups/:groupId/notes", groupId), {
+                title, description: noteDescription, createdBy: agent.name,
+            });
+            noteId = noteRes?.id;
+        }
+        printJson({
+            id: groupId,
+            name: created.name,
+            working_dir: created.working_dir,
+            type: created.type ?? (a2aDirect ? "a2a_direct" : "chat"),
+            memberCount: agents.length,
+            guidanceTemplate,
+            messagePosted,
+            noteId,
+            hint: a2aDirect
+                ? `单播群(unicast):消息只入库,不广播。叫醒对方: rotom --as=<你> group send ${groupId} <对方> "<问题>" --need-reply。轮询回复: bash skill/rotom-bus-host/scripts/poll-replies.sh ${groupId} --as <你>`
+                : `验证: rotom group members ${groupId}   |   rotom group history ${groupId} --limit 20`,
+        });
+        return;
+    }
+    if (sub === "list") {
+        const data = await api(agent, "GET", "/groups");
+        printTable(data.map((g) => ({
+            id: g.id,
+            name: g.name,
+            members: (g.members?.length ?? 0),
+            type: g.type || "chat",
+            created_at: g.created_at,
+            archived: g.archived_at ? "yes" : "",
+        })), ["id", "name", "members", "type", "created_at", "archived"]);
+        return;
+    }
+    if (sub === "members") {
+        const groupId = rest[1];
+        if (!groupId)
+            usage("group members", "<groupId>");
+        const data = await api(agent, "GET", route("/groups/:groupId", groupId));
+        const members = (data.members || []);
+        // 非.pretty 走完整 JSON,保留 profile 嵌套结构供 agent 程序化读取;
+        // .pretty 走扁平表格,bio 截断 40 字符避免撑爆终端。
+        if (!isPretty()) {
+            printJson(members);
+            return;
+        }
+        printTable(members.map((m) => ({
+            agent_name: m.agent_name,
+            position: m.profile?.position ?? "",
+            bio: (m.profile?.bio ?? "").slice(0, 40),
+            category: m.profile?.category ?? "",
+            status: m.status ?? "",
+        })), ["agent_name", "position", "bio", "category", "status"]);
+        return;
+    }
+    if (sub === "history") {
+        const groupId = rest[1];
+        if (!groupId)
+            usage("group history", "<groupId>");
+        const limit = flagInt(flags, "limit") ?? 50;
+        const contentLen = flagInt(flags, "content-len") ?? 200;
+        const hideExec = flags["no-exec"] === true;
+        const clean = flags["clean"] !== false;
+        const data = await api(agent, "GET", `${route("/groups/:groupId/messages", groupId)}${qs({ limit })}`);
+        // --no-exec 过滤 sender=system 且以「请求执行命令:」开头的 shell 调用通知,
+        // 这类消息占行多但很少是用户想看的回复主体。
+        const filtered = hideExec
+            ? data.filter((m) => !(m.sender === "system" && /^请求执行命令[::]/.test(m.content || "")))
+            : data;
+        printTable(filtered.map((m) => {
+            // --clean 去掉行内 [xxx:yyy]...[/xxx:yyy] 形式的 agent 状态/工具标记
+            // ([status:thinking] / [tool:exec] / [tool-result:exec] 等),只留自然语言主体。
+            let content = (m.content || "").replace(/\s+/g, " ");
+            if (clean) {
+                content = content
+                    .replace(/\[(\w[\w-]*(?::\w[\w-]*)?)\].*?\[\/\1\]/g, "")
+                    .replace(/\s+/g, " ")
+                    .trim();
+            }
+            return {
+                time: m.created_at,
+                sender: m.sender,
+                content: content.slice(0, contentLen),
+            };
+        }), ["time", "sender", "content"]);
+        return;
+    }
+    if (sub === "new-messages") {
+        const groupId = rest[1];
+        if (!groupId)
+            usage("group new-messages", "<groupId> --since <ISO> [--content-len N] [--no-clean]");
+        const since = flagStr(flags, "since");
+        if (!since)
+            fail("--since is required (北京时间字符串如 \"2026-06-30 18:02:04\" 或 UTC ISO)");
+        const contentLen = flagInt(flags, "content-len") ?? 200;
+        const clean = flags["clean"] !== false;
+        const data = await api(agent, "GET", `${route("/groups/:groupId/messages", groupId)}${qs({ since })}`);
+        printTable(data.map((m) => {
+            let content = (m.content || "").replace(/\s+/g, " ");
+            if (clean) {
+                content = content
+                    .replace(/\[(\w[\w-]*(?::\w[\w-]*)?)\].*?\[\/\1\]/g, "")
+                    .replace(/\s+/g, " ")
+                    .trim();
+            }
+            return {
+                time: m.created_at,
+                sender: m.sender,
+                content: content.slice(0, contentLen),
+            };
+        }), ["time", "sender", "content"]);
+        return;
+    }
+    if (sub === "send") {
+        const groupId = rest[1];
+        const target = rest[2];
+        const message = rest.slice(3).join(" ");
+        if (!groupId || !target || !message)
+            usage("group send", "<groupId> <target> <message...> [--no-dispatch] [--need-reply]");
+        const body = { target, message };
+        if (flags["no-dispatch"] === true)
+            body.noDispatch = true;
+        if (flags["need-reply"] === true)
+            body.needReply = true;
+        const data = await api(agent, "POST", route("/cli/groups/:groupId/send", groupId), body);
+        printJson(data);
+        return;
+    }
+    if (sub === "upload") {
+        const groupId = rest[1];
+        const filePath = rest[2];
+        if (!groupId || !filePath)
+            usage("group upload", "<groupId> <filePath> [--markdown]");
+        const expanded = filePath.startsWith("~/") ? path.join(process.env.HOME || "", filePath.slice(2)) : filePath;
+        if (!fs.existsSync(expanded))
+            fail(`file not found: ${expanded}`);
+        const mimeType = guessMime(expanded);
+        if (!mimeType)
+            fail(`unsupported extension (allowed: ${Object.keys(EXT_TO_MIME).join(", ")})`);
+        const bytes = fs.readFileSync(expanded);
+        // 15MB cap mirrors server-side MAX_UPLOAD_BYTES — fail fast instead of
+        // uploading a body the server will reject.
+        const MAX = 15 * 1024 * 1024;
+        if (bytes.length > MAX)
+            fail(`file too large: ${bytes.length} bytes > ${MAX} bytes`);
+        const dataBase64 = bytes.toString("base64");
+        const fileName = path.basename(expanded);
+        const data = await api(agent, "POST", "/uploads", { groupId, fileName, mimeType, dataBase64 });
+        if (flags.markdown) {
+            // Print only the markdown image token; agents / shell pipelines can
+            // capture and paste directly into `rotom group send` message body.
+            process.stdout.write(`![${fileName}](${data.url})\n`);
+        }
+        else {
+            printJson(data);
+        }
+        return;
+    }
+    if (sub === "archive") {
+        const groupId = rest[1];
+        if (!groupId)
+            usage("group archive", "<groupId>");
+        const data = await api(agent, "PATCH", route("/groups/:groupId", groupId), { archived: true });
+        printJson(data);
+        return;
+    }
+    if (sub === "unarchive") {
+        const groupId = rest[1];
+        if (!groupId)
+            usage("group unarchive", "<groupId>");
+        const data = await api(agent, "PATCH", route("/groups/:groupId", groupId), { archived: false });
+        printJson(data);
+        return;
+    }
+    unknownSubcommand("group", sub);
+}

package/dist/cli/identity.js

@@ -0,0 +1,62 @@
+import { nowBeijing } from "../shared/time.js";
+/**
+ * rotom identity — whoami / status commands.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROTOM_HOME, masterHttpUrl, api, printJson, fail, failKind, } from "./common.js";
+export async function cmdWhoami(agent) {
+    const data = await api(agent, "GET", "/whoami");
+    printJson(data);
+}
+function resolveMasterUrlForStatus() {
+    return resolveLocalMasterUrl();
+}
+/**
+ * 解析本机 master 的 HTTP base URL,用于 federation team CLI 等无 agent
+ * 上下文场景。优先级:ROTOM_MASTER env > ~/.rotom/executor.config.json#master
+ * > 失败(让 caller 给清晰提示)。
+ */
+export function resolveLocalMasterUrl() {
+    const env = process.env.ROTOM_MASTER;
+    if (env)
+        return masterHttpUrl(env);
+    const cfgPath = path.join(ROTOM_HOME, "executor.config.json");
+    try {
+        const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+        if (raw?.master)
+            return masterHttpUrl(raw.master);
+    }
+    catch { /* ignore */ }
+    fail("cannot resolve local master URL. Set ROTOM_MASTER, have ~/.rotom/executor.config.json, " +
+        "or start the master first (e.g. `rotom master start --daemon`).");
+}
+export async function cmdStatus(_rest, _flags) {
+    const url = resolveMasterUrlForStatus();
+    const endpoint = `${url}/health`;
+    for (let attempt = 1; attempt <= 2; attempt++) {
+        let resp;
+        try {
+            resp = await fetch(endpoint);
+            const data = await resp.json();
+            printJson({
+                status: resp.ok ? "ok" : "unhealthy",
+                master: url,
+                total: data.total ?? null,
+                online: data.online ?? null,
+                domains: data.domains ?? null,
+                checkedAt: nowBeijing(),
+            });
+            return;
+        }
+        catch (e) {
+            const reason = e.message;
+            const partial = resp !== undefined;
+            if (attempt < 2 && !partial) {
+                await new Promise((r) => setTimeout(r, 800));
+                continue;
+            }
+            failKind(partial ? "partial-response" : "network", url, reason, partial ? resp.status : 0);
+        }
+    }
+}

package/dist/cli/init.js

@@ -0,0 +1,268 @@
+/**
+ * rotom init — first-time bootstrap (detect CLI tools, register agents, write config).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import * as readline from "node:readline";
+import { ROTOM_HOME, DEFAULT_EXECUTOR_CONFIG, fail, flagStr, } from "./common.js";
+import { masterFetch, masterHttpBase, masterWsBase } from "./routes.js";
+// ── Bootstrap helpers ─────────────────────────────────────────────────────
+const INIT_KNOWN_TOOLS = ["claude", "codex", "hermes", "openclaw", "pi"];
+function detectCliTools(wanted) {
+    const out = [];
+    for (const tool of wanted) {
+        try {
+            const p = execSync(`command -v ${tool}`, { stdio: ["ignore", "pipe", "ignore"] })
+                .toString()
+                .trim();
+            if (p)
+                out.push({ tool, path: p });
+        }
+        catch {
+            /* not installed */
+        }
+    }
+    return out;
+}
+function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function askYN(question, defaultYes) {
+    return new Promise((resolve) => {
+        const hint = defaultYes ? "[Y/n]" : "[y/N]";
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`${question} ${hint}: `, (ans) => {
+            rl.close();
+            const a = ans.trim().toLowerCase();
+            if (!a)
+                return resolve(defaultYes);
+            if (a === "y" || a === "yes")
+                return resolve(true);
+            if (a === "n" || a === "no")
+                return resolve(false);
+            resolve(defaultYes);
+        });
+    });
+}
+function askText(question, defaultValue) {
+    return new Promise((resolve) => {
+        const suffix = defaultValue ? ` [${defaultValue}]` : "";
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`${question}${suffix}: `, (ans) => {
+            rl.close();
+            const trimmed = ans.trim();
+            resolve(trimmed || defaultValue || "");
+        });
+    });
+}
+function parseMasterSpec(spec, defaultPort) {
+    let s = spec.trim();
+    s = s.replace(/^wss?:\/\//, "").replace(/^https?:\/\//, "");
+    s = s.replace(/\/+$/, "");
+    let host = s;
+    let port = defaultPort;
+    const colon = s.lastIndexOf(":");
+    if (colon !== -1) {
+        const tail = s.slice(colon + 1);
+        const n = Number(tail);
+        if (Number.isInteger(n) && n > 0 && n < 65536) {
+            host = s.slice(0, colon);
+            port = n;
+        }
+    }
+    if (!host)
+        fail(`invalid master spec: ${spec}`);
+    return { host, port, url: masterWsBase(host, port) };
+}
+/**
+ * Wrap masterFetch so a network-level failure (DNS, ECONNREFUSED, etc.) fails
+ * with the same message the old httpJsonNoAuth helper emitted, instead of
+ * bubbling as an unhandled rejection. The probe path in cmdInit uses
+ * masterFetch directly with `.catch(() => null)` because it wants the
+ * "master unreachable — start it first" recovery message below.
+ */
+async function masterFetchOrFail(url, init) {
+    try {
+        return await masterFetch(url, init);
+    }
+    catch (e) {
+        fail(`network error calling ${url}: ${e.message}`);
+    }
+}
+async function listMasterDomains(httpBase) {
+    const { status, data } = await masterFetchOrFail(`${httpBase}/api/domains`, { method: "GET" });
+    if (status !== 200)
+        fail(`failed to list domains: HTTP ${status}`);
+    const d = data;
+    return Array.isArray(d) ? d : d?.domains ?? [];
+}
+async function ensureDomain(httpBase, name) {
+    const { status, data } = await masterFetchOrFail(`${httpBase}/api/domains`, {
+        method: "POST",
+        body: JSON.stringify({ name }),
+    });
+    if (status === 200 || status === 201)
+        return data;
+    if (status === 409)
+        return { name }; // already exists
+    fail(`failed to create domain "${name}": HTTP ${status} ${JSON.stringify(data)}`);
+}
+async function registerAgent(httpBase, name, domain, cliTool) {
+    const { status, data } = await masterFetchOrFail(`${httpBase}/api/agents`, {
+        method: "POST",
+        body: JSON.stringify({ name, domain, cliTool }),
+    });
+    if (status !== 200 && status !== 201) {
+        fail(`failed to register agent "${name}": HTTP ${status} ${JSON.stringify(data)}`);
+    }
+    return {
+        name: data.name ?? name,
+        token: data.mesh_token ?? data.token ?? "",
+        cliTool,
+    };
+}
+async function pickDomain(master, hintFlag, yesMode = false) {
+    const httpBase = masterHttpBase(master.host, master.port);
+    const existing = await listMasterDomains(httpBase);
+    if (hintFlag) {
+        const match = existing.find((d) => d.name === hintFlag);
+        if (match)
+            return match.name;
+        const created = await ensureDomain(httpBase, hintFlag);
+        return created.name;
+    }
+    if (existing.length === 1 && yesMode)
+        return existing[0].name;
+    if (existing.length > 0 && !yesMode) {
+        process.stdout.write("Existing domains:\n");
+        for (const d of existing)
+            process.stdout.write(`  ${d.name}\n`);
+        const pick = await askText("Domain to use", existing[0].name);
+        const match = existing.find((d) => d.name === pick);
+        if (match)
+            return match.name;
+        const created = await ensureDomain(httpBase, pick);
+        return created.name;
+    }
+    if (yesMode) {
+        const created = await ensureDomain(httpBase, "default");
+        return created.name;
+    }
+    const name = await askText("No domains found. Create domain", "default");
+    const created = await ensureDomain(httpBase, name);
+    return created.name;
+}
+// ── cmdInit ───────────────────────────────────────────────────────────────
+export async function cmdInit(_rest, flags) {
+    const yesMode = flags.yes === true || flags.y === true;
+    const force = flags.force === true;
+    const masterSpec = flagStr(flags, "master");
+    const domainFlag = flagStr(flags, "domain");
+    const namePrefix = flagStr(flags, "name-prefix") || process.env.USER || "user";
+    const toolsFlag = flagStr(flags, "tools");
+    const wantedTools = (toolsFlag ? toolsFlag.split(",").map((s) => s.trim()).filter(Boolean) : [...INIT_KNOWN_TOOLS]);
+    if (!isInteractive() && !yesMode) {
+        fail("rotom init needs an interactive TTY (or pass --yes to accept all defaults)");
+    }
+    if (fs.existsSync(DEFAULT_EXECUTOR_CONFIG) && !force) {
+        if (yesMode) {
+            fail(`${DEFAULT_EXECUTOR_CONFIG} already exists. Re-run with --force to overwrite.`);
+        }
+        const overwrite = await askYN(`${DEFAULT_EXECUTOR_CONFIG} already exists. Overwrite?`, false);
+        if (!overwrite) {
+            process.stdout.write("Aborted. Existing file left untouched.\n");
+            return;
+        }
+    }
+    process.stdout.write(`\nScanning for CLI tools (${wantedTools.join(", ")})...\n`);
+    const detected = detectCliTools(wantedTools);
+    if (detected.length === 0) {
+        fail(`none of [${wantedTools.join(", ")}] are on PATH. Install at least one, or pass --tools with what's available.`);
+    }
+    for (const { tool, path: p } of detected) {
+        process.stdout.write(`  \u2713 ${tool}  (${p})\n`);
+    }
+    for (const tool of wantedTools) {
+        if (!detected.find((d) => d.tool === tool))
+            process.stdout.write(`  \u2717 ${tool}  (not installed)\n`);
+    }
+    const selected = [];
+    for (const { tool, path: p } of detected) {
+        if (yesMode) {
+            selected.push({ tool, path: p, name: `${namePrefix}-${tool}` });
+            continue;
+        }
+        const want = await askYN(`Register ${tool}?`, true);
+        if (!want)
+            continue;
+        const defaultName = `${namePrefix}-${tool}`;
+        const name = (await askText(`  Name for ${tool}`, defaultName)).trim();
+        if (!name)
+            fail("name cannot be empty");
+        selected.push({ tool, path: p, name });
+    }
+    if (selected.length === 0) {
+        process.stdout.write("\nNo tools selected. Nothing to do.\n");
+        return;
+    }
+    const master = masterSpec
+        ? parseMasterSpec(masterSpec, 28800)
+        : yesMode
+            ? parseMasterSpec("127.0.0.1:28800", 28800)
+            : await (async () => {
+                const ip = await askText("Master IP", "127.0.0.1");
+                const portStr = await askText("Master port", "28800");
+                const port = Number(portStr);
+                if (!Number.isInteger(port) || port <= 0)
+                    fail("invalid port");
+                return { host: ip, port, url: masterWsBase(ip, port) };
+            })();
+    process.stdout.write(`\nMaster: ${master.url}\n`);
+    const httpBase = masterHttpBase(master.host, master.port);
+    const probe = await masterFetch(`${httpBase}/api/domains`, { method: "GET" }).catch(() => null);
+    if (!probe || probe.status === 0) {
+        fail(`master ${master.url} unreachable. Start it first (e.g. \`mesh-master start --daemon\`) or check the IP.`);
+    }
+    if (probe.status >= 500) {
+        fail(`master ${master.url} returned HTTP ${probe.status}: ${JSON.stringify(probe.data)}`);
+    }
+    const domain = await pickDomain(master, domainFlag, yesMode);
+    process.stdout.write(`Domain: ${domain}\n`);
+    process.stdout.write(`\nRegistering ${selected.length} agent(s)...\n`);
+    const workers = [];
+    for (const s of selected) {
+        const reg = await registerAgent(httpBase, s.name, domain, s.tool);
+        process.stdout.write(`  \u2713 ${reg.name}  (${s.tool})  token=${reg.token.slice(0, 12)}...\n`);
+        workers.push(reg);
+    }
+    if (!fs.existsSync(ROTOM_HOME))
+        fs.mkdirSync(ROTOM_HOME, { recursive: true });
+    const defaultBase = path.join(ROTOM_HOME, "artifacts");
+    const workingDir = yesMode
+        ? defaultBase
+        : (await askText("Working dir base (per-group cwd will be <base>/<groupId>)", defaultBase)).trim();
+    if (!workingDir)
+        fail("workingDir cannot be empty");
+    if (!path.isAbsolute(workingDir)) {
+        if (yesMode)
+            fail(`workingDir must be an absolute path, got: ${workingDir}`);
+        const expand = await askYN(`workingDir "${workingDir}" is not absolute. Use as-is?`, false);
+        if (!expand)
+            fail("aborted: workingDir must be absolute");
+    }
+    const cfg = {
+        master: master.url,
+        workers: workers.map((w) => ({
+            name: w.name,
+            token: w.token,
+            cliTool: w.cliTool,
+            workingDir,
+            profile: { category: "Agent" },
+        })),
+    };
+    fs.writeFileSync(DEFAULT_EXECUTOR_CONFIG, JSON.stringify(cfg, null, 2) + "\n");
+    process.stdout.write(`\nWrote ${DEFAULT_EXECUTOR_CONFIG} with ${workers.length} worker(s).\n`);
+    process.stdout.write(`  base workingDir: ${workingDir} (per-group: <base>/<groupId>)\n`);
+    process.stdout.write("Next: run \`pnpm executor\` (or \`rotom executor\`) to connect them.\n");
+}