u-foo 1.8.8 → 1.9.0

package/bin/uclaude.js

@@ -6,8 +6,18 @@
  */
 
 const AgentLauncher = require("../src/agent/launcher");
+const { resolveDefaultManualBootstrap } = require("../src/agent/defaultBootstrap");
 
 const launcher = new AgentLauncher("claude-code", "claude");
-const args = process.argv.slice(2);
+const resolved = resolveDefaultManualBootstrap({
+  projectRoot: process.cwd(),
+  agentType: "claude-code",
+  args: process.argv.slice(2),
+  env: process.env,
+});
 
-launcher.launch(args);
+for (const [key, value] of Object.entries(resolved.env || {})) {
+  process.env[key] = String(value);
+}
+
+launcher.launch(resolved.args);

package/bin/ucodex.js

@@ -6,8 +6,18 @@
  */
 
 const AgentLauncher = require("../src/agent/launcher");
+const { resolveDefaultManualBootstrap } = require("../src/agent/defaultBootstrap");
 
 const launcher = new AgentLauncher("codex", "codex");
-const args = process.argv.slice(2);
+const resolved = resolveDefaultManualBootstrap({
+  projectRoot: process.cwd(),
+  agentType: "codex",
+  args: process.argv.slice(2),
+  env: process.env,
+});
 
-launcher.launch(args);
+for (const [key, value] of Object.entries(resolved.env || {})) {
+  process.env[key] = String(value);
+}
+
+launcher.launch(resolved.args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.8.8",
+  "version": "1.9.0",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/agent/defaultBootstrap.js

@@ -0,0 +1,121 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { SHARED_UFOO_PROTOCOL } = require("../group/bootstrap");
+const { getUfooPaths } = require("../ufoo/paths");
+
+function asTrimmedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function hasArg(args = [], names = []) {
+  if (!Array.isArray(args) || args.length === 0) return false;
+  const known = new Set((Array.isArray(names) ? names : []).map((item) => asTrimmedString(item)).filter(Boolean));
+  return args.some((item) => {
+    const text = asTrimmedString(item);
+    if (!text) return false;
+    if (known.has(text)) return true;
+    const eqIndex = text.indexOf("=");
+    if (eqIndex <= 0) return false;
+    return known.has(text.slice(0, eqIndex).trim());
+  });
+}
+
+function hasMetaCommandArgs(args = []) {
+  return hasArg(args, ["-h", "--help", "-v", "--version"]);
+}
+
+function buildDefaultStartupBootstrapPrompt({ agentType = "" } = {}) {
+  const normalizedAgent = asTrimmedString(agentType).toLowerCase();
+  const displayAgent = normalizedAgent === "claude-code"
+    ? "Claude"
+    : (normalizedAgent === "codex" ? "Codex" : "agent");
+  return [
+    `Session bootstrap for ${displayAgent}.`,
+    "Adopt the following ufoo coordination protocol silently.",
+    "Do not reply to this bootstrap message unless the user explicitly asks about it. After applying it, continue the active task or wait for user input.",
+    SHARED_UFOO_PROTOCOL,
+  ].join("\n\n");
+}
+
+function defaultBootstrapFile(projectRoot, agentType = "") {
+  const safeAgentType = asTrimmedString(agentType).replace(/[^a-zA-Z0-9._-]/g, "-") || "agent";
+  return path.join(getUfooPaths(projectRoot).agentDir, safeAgentType, "default-bootstrap.md");
+}
+
+function prepareDefaultBootstrapFile({
+  projectRoot,
+  agentType = "",
+  promptText = "",
+  targetFile = "",
+} = {}) {
+  const root = asTrimmedString(projectRoot) || process.cwd();
+  const file = asTrimmedString(targetFile) || defaultBootstrapFile(root, agentType);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, String(promptText || ""), "utf8");
+  return { ok: true, file };
+}
+
+function resolveDefaultManualBootstrap({
+  projectRoot,
+  agentType = "",
+  args = [],
+  env = process.env,
+} = {}) {
+  const normalizedAgent = asTrimmedString(agentType).toLowerCase();
+  const currentEnv = env && typeof env === "object" ? env : {};
+  const currentArgs = Array.isArray(args) ? args.slice() : [];
+  if (
+    currentEnv.UFOO_SKIP_DEFAULT_BOOTSTRAP === "1"
+    || currentEnv.UFOO_STARTUP_BOOTSTRAP_TEXT
+    || hasMetaCommandArgs(currentArgs)
+  ) {
+    return { args: currentArgs, env: {}, mode: "skip" };
+  }
+
+  if (normalizedAgent === "claude-code") {
+    if (hasArg(currentArgs, ["--append-system-prompt", "--system-prompt"])) {
+      return { args: currentArgs, env: {}, mode: "skip" };
+    }
+    const promptText = buildDefaultStartupBootstrapPrompt({ agentType: normalizedAgent });
+    const prepared = prepareDefaultBootstrapFile({
+      projectRoot,
+      agentType: normalizedAgent,
+      promptText,
+    });
+    return {
+      args: [...currentArgs, "--append-system-prompt", prepared.file],
+      env: {},
+      mode: "system-prompt-file",
+      file: prepared.file,
+      promptText,
+    };
+  }
+
+  if (normalizedAgent === "codex") {
+    if (currentArgs.length > 0) {
+      return { args: currentArgs, env: {}, mode: "skip" };
+    }
+    const promptText = buildDefaultStartupBootstrapPrompt({ agentType: normalizedAgent });
+    return {
+      args: currentArgs,
+      env: {
+        UFOO_STARTUP_BOOTSTRAP_TEXT: promptText,
+      },
+      mode: "post-launch-inject",
+      promptText,
+    };
+  }
+
+  return { args: currentArgs, env: {}, mode: "skip" };
+}
+
+module.exports = {
+  hasArg,
+  hasMetaCommandArgs,
+  buildDefaultStartupBootstrapPrompt,
+  defaultBootstrapFile,
+  prepareDefaultBootstrapFile,
+  resolveDefaultManualBootstrap,
+};

package/src/agent/launcher.js

@@ -37,6 +37,40 @@ async function connectWithRetry(sockPath, retries, delayMs) {
   return null;
 }
 
+async function notifyDaemonAgentReady(daemonSockPath, subscriberId, agentPid) {
+  if (!daemonSockPath || !subscriberId) return false;
+  const parsedAgentPid = Number.parseInt(agentPid, 10);
+  if (!Number.isFinite(parsedAgentPid) || parsedAgentPid <= 0) return false;
+
+  const startTime = Date.now();
+  try {
+    const daemonSock = await connectWithRetry(daemonSockPath, 3, 100);
+    if (!daemonSock) {
+      if (process.env.UFOO_DEBUG) {
+        console.error("[ready] failed to connect to daemon after retries, will use fallback delay");
+      }
+      return false;
+    }
+
+    daemonSock.write(`${JSON.stringify({
+      type: IPC_REQUEST_TYPES.AGENT_READY,
+      subscriberId,
+      agentPid: parsedAgentPid,
+    })}\n`);
+    daemonSock.end();
+
+    if (process.env.UFOO_DEBUG) {
+      console.error(`[ready] notified daemon in ${Date.now() - startTime}ms`);
+    }
+    return true;
+  } catch (err) {
+    if (process.env.UFOO_DEBUG) {
+      console.error(`[ready] daemon notification error: ${err.message}, will use fallback delay`);
+    }
+    return false;
+  }
+}
+
 async function probeDaemonSocket(sockPath) {
   try {
     const client = await connectSocket(sockPath);
@@ -190,6 +224,42 @@ function computeInjectedSubmitDelayMs(agentType, text) {
   return delayMs;
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function logInjectedCommand(wrapper, source, commandText) {
+  if (!wrapper || !wrapper.logger) return;
+  const text = String(commandText || "");
+  if (!text) return;
+  const logEntry = {
+    ts: Date.now(),
+    dir: "in",
+    data: { text, encoding: "utf8", size: text.length },
+    source,
+  };
+  wrapper.logger.write(JSON.stringify(logEntry) + "\n");
+}
+
+async function injectPtyCommand(wrapper, agentType, commandText, source = "inject") {
+  const text = String(commandText || "");
+  if (!wrapper || !text) return false;
+  const normalizedAgentType = String(agentType || "").trim().toLowerCase();
+  const submitDelayMs = computeInjectedSubmitDelayMs(agentType, text);
+  wrapper.write(text);
+  if (normalizedAgentType === "claude-code") {
+    await sleep(submitDelayMs);
+    wrapper.write("\r");
+  } else {
+    await sleep(submitDelayMs);
+    wrapper.write("\x1b");
+    await sleep(100);
+    wrapper.write("\r");
+  }
+  logInjectedCommand(wrapper, source, text);
+  return true;
+}
+
 async function resolveHostRegistrationData(launchMode) {
   if (launchMode !== "host") {
     return {
@@ -417,6 +487,7 @@ class AgentLauncher {
     return new Promise((resolve, reject) => {
       let buffer = "";
       let settled = false;
+      const registerTimeoutMs = parseInt(process.env.UFOO_REGISTER_TIMEOUT_MS, 10) || 8000;
       const timeout = setTimeout(() => {
         if (settled) return;
         settled = true;
@@ -426,7 +497,7 @@ class AgentLauncher {
           // ignore
         }
         reject(new Error("register_agent timeout"));
-      }, 8000);
+      }, registerTimeoutMs);
 
       const cleanup = () => {
         clearTimeout(timeout);
@@ -497,6 +568,11 @@ class AgentLauncher {
       },
     });
 
+    if (resolveLaunchMode() === "host" && child.pid) {
+      const daemonSockPath = getUfooPaths(this.cwd).ufooSock;
+      notifyDaemonAgentReady(daemonSockPath, subscriberId, child.pid).catch(() => {});
+    }
+
     child.on("error", (err) => {
       console.error(`[${this.command}] Failed to start:`, err.message);
       process.exit(1);
@@ -568,6 +644,7 @@ class AgentLauncher {
       }
 
       // 7. 启动命令（PTY wrapper或直接spawn）
+      const startupBootstrapText = String(process.env.UFOO_STARTUP_BOOTSTRAP_TEXT || "").trim();
 
       // 7.1 PTY启用条件（显式开关 + 自动检测）
       let shouldUsePty = false;
@@ -665,33 +742,11 @@ class AgentLauncher {
               }
             }
 
-            const startTime = Date.now();
-            try {
-              const daemonSock = await connectWithRetry(daemonSockPath, 3, 100);
-              if (daemonSock) {
-                daemonSock.write(`${JSON.stringify({
-                  type: IPC_REQUEST_TYPES.AGENT_READY,
-                  subscriberId,
-                  agentPid: wrapper.pty ? wrapper.pty.pid : 0,
-                })}\n`);
-                daemonSock.end();
-
-                const notifyTime = Date.now() - startTime;
-                if (process.env.UFOO_DEBUG) {
-                  console.error(`[ready] notified daemon in ${notifyTime}ms`);
-                }
-              } else {
-                if (process.env.UFOO_DEBUG) {
-                  console.error(`[ready] failed to connect to daemon after retries, will use fallback delay`);
-                }
-              }
-            } catch (err) {
-              // 忽略通知失败（probe会通过fallback延迟执行）
-              if (process.env.UFOO_DEBUG) {
-                console.error(`[ready] daemon notification error: ${err.message}, will use fallback delay`);
-              }
+            if (startupBootstrapText && wrapper.pty) {
+              await injectPtyCommand(wrapper, this.agentType, startupBootstrapText, "startup-bootstrap");
             }
 
+            await notifyDaemonAgentReady(daemonSockPath, subscriberId, wrapper.pty ? wrapper.pty.pid : 0);
           });
 
           // Fallback：如果10秒后还没检测到ready，强制标记为ready
@@ -799,37 +854,8 @@ class AgentLauncher {
                       continue;
                     }
                     // 注入命令到PTY（带延迟确保输入完成）
-                    // Claude Code (Ink TUI) interprets ESC+CR within ~100ms as
-                    // Alt+Enter (newline) instead of two separate keys. Use a
-                    // longer gap so the escape sequence parser times out.
-                    const commandText = String(req.command);
-                    const submitDelayMs = computeInjectedSubmitDelayMs(this.agentType, commandText);
-                    wrapper.write(commandText);
-                    if (normalizedAgentType === "claude-code") {
-                      // Claude Code: send CR directly without ESC.
-                      // ESC before CR is interpreted as Alt+Enter (newline).
-                      setTimeout(() => {
-                        wrapper.write("\r");
-                      }, submitDelayMs);
-                    } else {
-                      // Codex/others: ESC dismisses autocomplete, then CR submits.
-                      setTimeout(() => {
-                        wrapper.write("\x1b");
-                        setTimeout(() => {
-                          wrapper.write("\r");
-                        }, 100);
-                      }, submitDelayMs);
-                    }
+                    void injectPtyCommand(wrapper, this.agentType, req.command, "inject");
                     client.write(JSON.stringify({ ok: true }) + "\n");
-                    if (wrapper.logger) {
-                      const logEntry = {
-                        ts: Date.now(),
-                        dir: "in",
-                        data: { text: req.command, encoding: "utf8", size: req.command.length },
-                        source: "inject",
-                      };
-                      wrapper.logger.write(JSON.stringify(logEntry) + "\n");
-                    }
                   } else if (req.type === PTY_SOCKET_MESSAGE_TYPES.RAW && req.data) {
                     // Raw PTY write (no Enter appended) - for TTY view passthrough
                     wrapper.write(req.data);
@@ -938,5 +964,7 @@ class AgentLauncher {
 // Exported for testing
 AgentLauncher._sanitizeNickname = (nick) => nick.replace(/[^a-zA-Z0-9_-]/g, "");
 AgentLauncher._findPreviousSession = findPreviousSession;
+AgentLauncher._notifyDaemonAgentReady = notifyDaemonAgentReady;
+AgentLauncher._injectPtyCommand = injectPtyCommand;
 
 module.exports = AgentLauncher;

package/src/chat/commandExecutor.js

@@ -8,6 +8,7 @@ const { resolveTransport } = require("../code/nativeRunner");
 const { parseIntervalMs, formatIntervalMs } = require("./cronScheduler");
 const { isGlobalControllerProjectRoot, resolveGlobalControllerUfooDir } = require("../globalMode");
 const { loadPromptProfileRegistry } = require("../group/promptProfiles");
+const { resolveSoloAgentType } = require("../solo/commands");
 
 function defaultCreateDoctor(projectRoot) {
   const UfooDoctor = require("../doctor");
@@ -528,10 +529,15 @@ function createCommandExecutor(options = {}) {
       return;
     }
 
-    const target = String(args[0] || "").trim();
-    const profile = String(args[1] || "").trim();
+    const target = action === "assign"
+      ? String(args[1] || "").trim()
+      : String(args[0] || "").trim();
+    const profile = action === "assign"
+      ? String(args[2] || "").trim()
+      : String(args[1] || "").trim();
     if (!target || !profile) {
-      logMessage("error", "{white-fg}✗{/white-fg} Usage: /role <agent-id|nickname> <prompt-profile>");
+      logMessage("error", "{white-fg}✗{/white-fg} Usage: /role assign <agent-id|nickname> <prompt-profile>");
+      logMessage("error", "       /role <agent-id|nickname> <prompt-profile>");
       logMessage("error", "       /role list");
       return;
     }
@@ -548,6 +554,95 @@ function createCommandExecutor(options = {}) {
     }
   }
 
+  async function handleSoloCommand(args = []) {
+    const subcommand = String(args[0] || "").trim().toLowerCase();
+    if (!subcommand) {
+      logMessage("error", "{white-fg}✗{/white-fg} Usage: /solo <run|list> ...");
+      return;
+    }
+
+    if (subcommand === "list" || subcommand === "ls") {
+      try {
+        const registry = loadPromptProfileRegistry(projectRoot);
+        const profiles = registry.profiles || [];
+        if (profiles.length === 0) {
+          logMessage("system", "{white-fg}⚙{/white-fg} No solo roles found.");
+          return;
+        }
+        logMessage("system", `{white-fg}⚙{/white-fg} Available solo roles (${profiles.length}):`);
+        for (const p of profiles) {
+          const aliases = p.aliases && p.aliases.length > 0 ? ` {gray-fg}(${p.aliases.join(", ")}){/gray-fg}` : "";
+          const source = p.source ? ` {cyan-fg}[${p.source}]{/cyan-fg}` : "";
+          const summary = p.summary ? `  ${p.summary}` : "";
+          logMessage("system", `  {bold}${escapeBlessed(p.id)}{/bold}${aliases}${source}`);
+          if (summary) {
+            logMessage("system", `    ${escapeBlessed(summary)}`);
+          }
+        }
+      } catch (err) {
+        logMessage("error", `{white-fg}✗{/white-fg} Failed to list solo roles: ${escapeBlessed(err.message)}`);
+      }
+      return;
+    }
+
+    if (subcommand !== "run") {
+      logMessage("error", `{white-fg}✗{/white-fg} Unknown solo action: ${escapeBlessed(subcommand)}`);
+      return;
+    }
+
+    const profile = String(args[1] || "").trim();
+    if (!profile) {
+      logMessage("error", "{white-fg}✗{/white-fg} Usage: /solo run <prompt-profile> [agent=codex|claude|ucode] [nickname=<name>] [scope=inplace|window]");
+      return;
+    }
+
+    const parsedOptions = {};
+    for (let i = 2; i < args.length; i += 1) {
+      const arg = args[i];
+      if (arg.includes("=")) {
+        const [key, value] = arg.split("=", 2);
+        parsedOptions[key] = value;
+      }
+    }
+
+    function normalizeLaunchScopeOption(value, fallback = "inplace") {
+      const raw = String(value || "").trim().toLowerCase();
+      if (!raw) return fallback;
+      if (raw === "inplace" || raw === "same" || raw === "current" || raw === "tab" || raw === "pane") {
+        return "inplace";
+      }
+      if (raw === "window" || raw === "separate" || raw === "new" || raw === "new-window" || raw === "external") {
+        return "window";
+      }
+      return "";
+    }
+
+    const config = loadConfig(projectRoot);
+    const agent = resolveSoloAgentType(config, parsedOptions.agent || parsedOptions.type || "");
+    const nickname = String(parsedOptions.nickname || "").trim();
+    const scopeRaw = parsedOptions.scope || parsedOptions.launch_scope || "";
+    const launchScope = normalizeLaunchScopeOption(scopeRaw, "inplace");
+    if (scopeRaw && !launchScope) {
+      logMessage("error", "{white-fg}✗{/white-fg} scope must be inplace|window");
+      return;
+    }
+
+    try {
+      send({
+        type: IPC_REQUEST_TYPES.LAUNCH_AGENT,
+        agent: agent === "ucode" ? "ufoo" : agent,
+        count: 1,
+        nickname,
+        prompt_profile: profile,
+        launch_scope: launchScope,
+        ...collectHostLaunchRequestContext(),
+      });
+      schedule(requestStatus, 1000);
+    } catch (err) {
+      logMessage("error", `{white-fg}✗{/white-fg} Solo launch failed: ${escapeBlessed(err.message)}`);
+    }
+  }
+
   async function handleResumeCommand(args = []) {
     const action = String(args[0] || "").toLowerCase();
     if (action === "list" || action === "ls") {
@@ -1218,6 +1313,9 @@ function createCommandExecutor(options = {}) {
       case "role":
         await handleRoleCommand(args);
         return true;
+      case "solo":
+        await handleSoloCommand(args);
+        return true;
       case "cron":
         await handleCronCommand(args);
         return true;
@@ -1250,6 +1348,7 @@ function createCommandExecutor(options = {}) {
     handleResumeCommand,
     handleProjectCommand,
     handleRoleCommand,
+    handleSoloCommand,
     handleCronCommand,
     handleGroupCommand,
     handleSettingsCommand,

package/src/chat/commands.js

@@ -67,7 +67,15 @@ const COMMAND_TREE = {
   "/role": {
     desc: "Assign preset role to an existing agent",
     children: {
-      list: { desc: "List available prompt profiles" },
+      assign: { desc: "Assign a role to an existing agent", order: 1 },
+      list: { desc: "List available prompt profiles", order: 2 },
+    },
+  },
+  "/solo": {
+    desc: "Solo role agent operations",
+    children: {
+      run: { desc: "Launch a solo role agent", order: 1 },
+      list: { desc: "List available solo roles", order: 2 },
     },
   },
   "/resume": {
@@ -111,10 +119,20 @@ function buildCommandRegistry(tree) {
       const entry = { cmd, desc: node.desc || "" };
       if (node.children) {
         entry.subcommands = Object.keys(node.children)
-          .sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }))
+          .sort((a, b) => {
+            const aNode = node.children[a] || {};
+            const bNode = node.children[b] || {};
+            const aOrder = Number.isFinite(aNode.order) ? aNode.order : Number.POSITIVE_INFINITY;
+            const bOrder = Number.isFinite(bNode.order) ? bNode.order : Number.POSITIVE_INFINITY;
+            if (aOrder !== bOrder) return aOrder - bOrder;
+            return a.localeCompare(b, "en", { sensitivity: "base" });
+          })
           .map((sub) => ({
             cmd: sub,
             desc: (node.children[sub] && node.children[sub].desc) || "",
+            order: Number.isFinite(node.children[sub] && node.children[sub].order)
+              ? node.children[sub].order
+              : undefined,
           }));
       }
       return entry;

package/src/chat/completionController.js

@@ -4,6 +4,13 @@ const FALLBACK_LAUNCH_SUBCOMMANDS = [
   { cmd: "ucode", desc: "Launch ucode core agent" },
 ];
 
+function sortSubcommandEntries(a, b) {
+  const aOrder = Number.isFinite(a && a.order) ? a.order : Number.POSITIVE_INFINITY;
+  const bOrder = Number.isFinite(b && b.order) ? b.order : Number.POSITIVE_INFINITY;
+  if (aOrder !== bOrder) return aOrder - bOrder;
+  return String(a && a.cmd ? a.cmd : "").localeCompare(String(b && b.cmd ? b.cmd : ""), "en", { sensitivity: "base" });
+}
+
 function createCompletionController(options = {}) {
   const {
     input,
@@ -12,6 +19,7 @@ function createCompletionController(options = {}) {
     promptBox,
     commandRegistry = [],
     getGroupTemplateCandidates = () => [],
+    getSoloProfileCandidates = () => [],
     getMentionCandidates = () => [],
     normalizeCommandPrefix = () => {},
     truncateText = (text) => String(text || ""),
@@ -143,6 +151,7 @@ function createCompletionController(options = {}) {
     const mainCmd = parts[0];
     const isLaunch = mainCmd && mainCmd.toLowerCase() === "/launch";
     const isGroup = mainCmd && mainCmd.toLowerCase() === "/group";
+    const isSolo = mainCmd && mainCmd.toLowerCase() === "/solo";
     const wantsSubcommands = (parts.length > 1 || (endsWithSpace && parts.length === 1));
 
     if (isGroup) {
@@ -169,6 +178,28 @@ function createCompletionController(options = {}) {
       }
     }
 
+    if (isSolo) {
+      const soloSubcommand = String(parts[1] || "").trim().toLowerCase();
+      const wantsSoloRunArgs = soloSubcommand === "run" && (parts.length > 2 || endsWithSpace);
+      if (wantsSoloRunArgs) {
+        const profileFilter = String(parts[2] || "").trim().toLowerCase();
+        return (Array.isArray(getSoloProfileCandidates()) ? getSoloProfileCandidates() : [])
+          .map((item) => {
+            const profileId = String(item && item.cmd ? item.cmd : item && item.id ? item.id : "").trim();
+            if (!profileId) return null;
+            const desc = String(item && item.desc ? item.desc : item && item.summary ? item.summary : "").trim();
+            return {
+              cmd: profileId,
+              desc,
+              isArgumentSuggestion: true,
+              argumentPrefix: "/solo run",
+            };
+          })
+          .filter((item) => item && (!profileFilter || item.cmd.toLowerCase().startsWith(profileFilter)))
+          .sort((a, b) => a.cmd.localeCompare(b.cmd, "en", { sensitivity: "base" }));
+      }
+    }
+
     if ((wantsSubcommands || isLaunch) && mainCmd && mainCmd.startsWith("/")) {
       const subFilter = parts[1] || "";
       const mainCmdObj = commandRegistry.find((item) =>
@@ -188,12 +219,12 @@ function createCompletionController(options = {}) {
         if (isLaunch) {
           return subs
             .map((sub) => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
-            .sort((a, b) => a.cmd.localeCompare(b.cmd));
+            .sort(sortSubcommandEntries);
         }
         return subs
           .filter((sub) => sub.cmd.toLowerCase().startsWith(subFilter.toLowerCase()))
           .map((sub) => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
-          .sort((a, b) => a.cmd.localeCompare(b.cmd));
+          .sort(sortSubcommandEntries);
       }
       return [];
     }
@@ -340,7 +371,11 @@ function createCompletionController(options = {}) {
 
     if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
       show(input.value);
-    } else if (selected.isSubcommand && selected.parentCmd === "/group" && selected.cmd === "run") {
+    } else if (
+      selected.isSubcommand
+      && ((selected.parentCmd === "/group" && selected.cmd === "run")
+        || (selected.parentCmd === "/solo" && selected.cmd === "run"))
+    ) {
       show(input.value);
     } else {
       hide();
@@ -384,7 +419,11 @@ function createCompletionController(options = {}) {
           applyPreview(nextPreview);
           if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
             show(input.value);
-          } else if (selected.isSubcommand && selected.parentCmd === "/group" && selected.cmd === "run") {
+          } else if (
+            selected.isSubcommand
+            && ((selected.parentCmd === "/group" && selected.cmd === "run")
+              || (selected.parentCmd === "/solo" && selected.cmd === "run"))
+          ) {
             show(input.value);
           } else {
             hide();

package/src/chat/daemonReconnect.js

@@ -1,3 +1,5 @@
+const { restartLocks } = require("./daemonTransport");
+
 function resolveDaemonConnection(daemonConnection) {
   return typeof daemonConnection === "function" ? daemonConnection() : daemonConnection;
 }
@@ -14,11 +16,10 @@ function restartDaemonFlow(options = {}) {
 
   const statusMsg = resolveStatusLine || ((text) => logMessage("status", text));
 
-  let restartInProgress = false;
-
   return async function restartDaemon() {
-    if (restartInProgress) return;
-    restartInProgress = true;
+    // Use global restart lock to prevent concurrent restart flows
+    if (restartLocks.get(projectRoot)) return;
+    restartLocks.set(projectRoot, true);
     statusMsg("{gray-fg}⚙{/gray-fg} Restarting daemon...");
     try {
       const connection = resolveDaemonConnection(daemonConnection);
@@ -34,7 +35,7 @@ function restartDaemonFlow(options = {}) {
         statusMsg("{gray-fg}✗{/gray-fg} Failed to reconnect to daemon");
       }
     } finally {
-      restartInProgress = false;
+      restartLocks.delete(projectRoot);
     }
   };
 }

package/src/chat/daemonTransport.js

@@ -1,5 +1,8 @@
 const { DAEMON_TRANSPORT_DEFAULTS } = require("./daemonTransportDefaults");
 
+// Global restart lock per project to prevent concurrent restart flows
+const restartLocks = new Map();
+
 function createDaemonTransport(options = {}) {
   const {
     projectRoot,
@@ -34,7 +37,9 @@ function createDaemonTransport(options = {}) {
     );
     if (!client) {
       // Retry once with a fresh daemon start and longer wait.
-      if (!isRunning(target.projectRoot)) {
+      // Check if a restart is already in progress via the explicit restart flow.
+      const isExplicitRestartInProgress = restartLocks.get(target.projectRoot);
+      if (!isExplicitRestartInProgress && !isRunning(target.projectRoot)) {
         startDaemon(target.projectRoot);
         await new Promise((resolve) => setTimeout(resolve, restartDelayMs));
       }
@@ -75,4 +80,5 @@ function createDaemonTransport(options = {}) {
 
 module.exports = {
   createDaemonTransport,
+  restartLocks,
 };

package/src/chat/index.js

@@ -18,6 +18,7 @@ const { getUfooPaths } = require("../ufoo/paths");
 const { startDaemon, stopDaemon, connectWithRetry } = require("./transport");
 const { escapeBlessed, stripBlessedTags, truncateText } = require("./text");
 const { COMMAND_REGISTRY, parseCommand, parseAtTarget } = require("./commands");
+const { buildPromptProfileCandidates } = require("../solo/commands");
 const inputMath = require("./inputMath");
 const { createStreamTracker } = require("./streamTracker");
 const agentDirectory = require("./agentDirectory");
@@ -559,6 +560,10 @@ async function runChat(projectRoot, options = {}) {
         source: item.source || "",
       }));
     },
+    getSoloProfileCandidates: () => {
+      const registry = loadPromptProfileRegistry(activeProjectRoot);
+      return buildPromptProfileCandidates(registry);
+    },
     getMentionCandidates: () => activeAgents.map((id) => ({
       id,
       label: getAgentLabel(id),

package/src/cli.js

@@ -7,6 +7,9 @@ const { runBusCoreCommand } = require("./cli/busCoreCommands");
 const { runCtxCommand } = require("./cli/ctxCoreCommands");
 const { runOnlineCommand } = require("./cli/onlineCoreCommands");
 const { runGroupCoreCommand } = require("./cli/groupCoreCommands");
+const { loadConfig } = require("./config");
+const { loadPromptProfileRegistry } = require("./group/promptProfiles");
+const { resolveSoloAgentType } = require("./solo/commands");
 const { listProjectRuntimes, getCurrentProjectRuntime } = require("./projects/registry");
 const { canonicalProjectRoot, buildProjectId } = require("./projects/projectId");
 const { getUfooPaths } = require("./ufoo/paths");
@@ -448,6 +451,68 @@ async function runCli(argv) {
           process.exitCode = 1;
         }
       });
+    program
+      .command("solo")
+      .description("Solo role agent operations")
+      .argument("<action>", "run|list")
+      .argument("[profile]", "Prompt profile id or alias")
+      .option("--agent <type>", "Agent type: codex|claude|ucode")
+      .option("--nickname <name>", "Optional nickname")
+      .option("--scope <scope>", "Launch scope: inplace|window", "inplace")
+      .option("--json", "Output role list as JSON")
+      .action(async (action, profile, opts) => {
+        try {
+          const projectRoot = process.cwd();
+          const subcommand = String(action || "").trim().toLowerCase();
+          if (subcommand === "list" || subcommand === "ls") {
+            const registry = loadPromptProfileRegistry(projectRoot);
+            if (opts.json) {
+              console.log(JSON.stringify({ profiles: registry.profiles || [] }, null, 2));
+              return;
+            }
+            const profiles = registry.profiles || [];
+            if (profiles.length === 0) {
+              console.log("No solo roles found.");
+              return;
+            }
+            console.log(`Available solo roles (${profiles.length}):`);
+            for (const p of profiles) {
+              const aliases = p.aliases && p.aliases.length > 0 ? ` (${p.aliases.join(", ")})` : "";
+              const source = p.source ? ` [${p.source}]` : "";
+              console.log(`  ${p.id}${aliases}${source}`);
+              if (p.summary) console.log(`    ${p.summary}`);
+            }
+            return;
+          }
+          if (subcommand !== "run") {
+            throw new Error(`Unknown solo action: ${subcommand}`);
+          }
+          const promptProfile = String(profile || "").trim();
+          if (!promptProfile) {
+            throw new Error("solo run requires <profile>");
+          }
+          await ensureDaemonRunning(projectRoot);
+          const config = loadConfig(projectRoot);
+          const agent = resolveSoloAgentType(config, opts.agent || "");
+          const scope = String(opts.scope || "inplace").trim().toLowerCase();
+          if (scope !== "inplace" && scope !== "window") {
+            throw new Error("scope must be inplace|window");
+          }
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "launch_agent",
+            agent: agent === "ucode" ? "ufoo" : agent,
+            nickname: String(opts.nickname || "").trim(),
+            prompt_profile: promptProfile,
+            count: 1,
+            launch_scope: scope,
+            ...collectHostLaunchRequestContext(),
+          });
+          console.log(resp?.data?.reply || `Launched ${agent} role ${promptProfile}`);
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
     program
       .command("role")
       .description("Assign a preset role to an existing agent")
@@ -1312,6 +1377,8 @@ async function runCli(argv) {
     console.log("  ufoo group status [groupId] [--json]");
     console.log("  ufoo group diagram <alias|groupId> [--ascii|--mermaid] [--json]");
     console.log("  ufoo group stop <groupId> [--json]");
+    console.log("  ufoo solo list [--json]");
+    console.log("  ufoo solo run <profile> [--agent <codex|claude|ucode>] [--nickname <name>] [--scope <inplace|window>]");
     console.log("  ufoo online server [--port 8787] [--host 127.0.0.1] [--token-file <path>]");
     console.log("  ufoo online token <subscriber> [--nickname <name>] [--server <url>] [--file <path>]");
     console.log("  ufoo online room create [--name <room>] --type public|private [--password <pwd>] [--created-by <name>] [--server <url>]");
@@ -1795,6 +1862,67 @@ async function runCli(argv) {
     })();
     return;
   }
+  if (cmd === "solo") {
+    const sub = String(rest[0] || "").trim().toLowerCase();
+    (async () => {
+      try {
+        const projectRoot = process.cwd();
+        if (sub === "list" || sub === "ls") {
+          const outputJson = rest.includes("--json");
+          const registry = loadPromptProfileRegistry(projectRoot);
+          if (outputJson) {
+            console.log(JSON.stringify({ profiles: registry.profiles || [] }, null, 2));
+            return;
+          }
+          const profiles = registry.profiles || [];
+          if (profiles.length === 0) {
+            console.log("No solo roles found.");
+            return;
+          }
+          console.log(`Available solo roles (${profiles.length}):`);
+          for (const p of profiles) {
+            const aliases = p.aliases && p.aliases.length > 0 ? ` (${p.aliases.join(", ")})` : "";
+            const source = p.source ? ` [${p.source}]` : "";
+            console.log(`  ${p.id}${aliases}${source}`);
+            if (p.summary) console.log(`    ${p.summary}`);
+          }
+          return;
+        }
+        if (sub === "run") {
+          const profile = String(rest[1] || "").trim();
+          if (!profile) throw new Error("solo run requires <profile>");
+          const agentIdx = rest.indexOf("--agent");
+          const agentInput = agentIdx !== -1 ? String(rest[agentIdx + 1] || "").trim() : "";
+          const nickIdx = rest.indexOf("--nickname");
+          const nickname = nickIdx !== -1 ? String(rest[nickIdx + 1] || "").trim() : "";
+          const scopeIdx = rest.indexOf("--scope");
+          const scope = scopeIdx !== -1 ? String(rest[scopeIdx + 1] || "").trim().toLowerCase() : "inplace";
+          if (scope !== "inplace" && scope !== "window") {
+            throw new Error("scope must be inplace|window");
+          }
+          await ensureDaemonRunning(projectRoot);
+          const config = loadConfig(projectRoot);
+          const agent = resolveSoloAgentType(config, agentInput);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "launch_agent",
+            agent: agent === "ucode" ? "ufoo" : agent,
+            nickname,
+            prompt_profile: profile,
+            count: 1,
+            launch_scope: scope,
+            ...collectHostLaunchRequestContext(),
+          });
+          console.log(resp?.data?.reply || `Launched ${agent} role ${profile}`);
+          return;
+        }
+        throw new Error(`Unknown solo action: ${sub || "(empty)"}`);
+      } catch (err) {
+        console.error(err.message || String(err));
+        process.exitCode = 1;
+      }
+    })();
+    return;
+  }
   if (cmd === "online") {
     const sub = rest[0] || "";
     if (!sub) {

package/src/daemon/groupOrchestrator.js

@@ -753,6 +753,7 @@ function createGroupOrchestrator(options = {}) {
     }
 
     const plan = buildLaunchPlan(validated.entry.data);
+    const templateDefaults = (validated.entry.data && validated.entry.data.defaults) || {};
     const groupId = generateGroupId(validated.entry.alias || alias, instance);
     const projectNicknamePrefix = buildProjectNicknamePrefix(projectRoot);
 
@@ -835,6 +836,12 @@ function createGroupOrchestrator(options = {}) {
       const item = compiled.executionPlan[i];
       const member = runtime.members[i];
       const extraEnv = {};
+      if (item.bootstrap_required) {
+        extraEnv.UFOO_SKIP_DEFAULT_BOOTSTRAP = "1";
+      }
+      if (Number.isInteger(templateDefaults.start_timeout_ms) && templateDefaults.start_timeout_ms > 0) {
+        extraEnv.UFOO_REGISTER_TIMEOUT_MS = String(templateDefaults.start_timeout_ms);
+      }
       let extraArgs = [];
       let bootstrapInjected = false;
 

package/src/daemon/index.js

@@ -201,16 +201,16 @@ function looksLikeRunningDaemon(projectRoot, pid) {
 function isRunning(projectRoot) {
   const pid = readPid(projectRoot);
   if (!pid) return false;
-  if (looksLikeRunningDaemon(projectRoot, pid)) {
-    return true;
-  }
+  return looksLikeRunningDaemon(projectRoot, pid);
+}
+
+function cleanupStaleState(projectRoot) {
   try {
     fs.unlinkSync(pidPath(projectRoot));
   } catch {
     // ignore
   }
   removeSocket(projectRoot);
-  return false;
 }
 
 function removeSocket(projectRoot) {
@@ -1051,6 +1051,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
             await init.init({ modules: "context,bus", project: root });
           }
           if (!isRunning(root)) {
+            cleanupStaleState(root);
             const daemonBin = path.join(__dirname, "..", "..", "bin", "ufoo.js");
             const child = spawn(process.execPath, [daemonBin, "daemon", "--start"], {
               detached: true,
@@ -1384,6 +1385,12 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           }
         }
       }
+      if (requestedProfile) {
+        op.extra_env = {
+          ...(op.extra_env && typeof op.extra_env === "object" ? op.extra_env : {}),
+          UFOO_SKIP_DEFAULT_BOOTSTRAP: "1",
+        };
+      }
       try {
         const opsResults = await handleOps(projectRoot, [op], processManager);
         const launchResult = opsResults.find((r) => r.action === "launch");
@@ -2323,4 +2330,4 @@ function stopDaemon(projectRoot) {
   return killed;
 }
 
-module.exports = { startDaemon, stopDaemon, isRunning, socketPath };
+module.exports = { startDaemon, stopDaemon, isRunning, cleanupStaleState, socketPath };

package/src/group/bootstrap.js

@@ -2,6 +2,15 @@
 
 const crypto = require("crypto");
 
+const SHARED_UFOO_PROTOCOL = [
+  "ufoo protocol:",
+  "- At session start, sync shared context with `ufoo ctx decisions -l` and `ufoo ctx decisions -n 1`.",
+  "- If your work produces knowledge with information value, record it before acting via `ufoo ctx decisions new \"Title\"`.",
+  "- Use `ufoo bus send <target-nickname> \"<message>\"` for agent-to-agent handoffs.",
+  "- If you receive pending bus work, execute it immediately, reply to the sender, then `ufoo bus ack \"$UFOO_SUBSCRIBER_ID\"`.",
+  "- Use `ufoo report` for controller/runtime status updates, not as a substitute for direct handoffs.",
+].join("\n");
+
 const SHARED_GROUP_PREFIX = [
   "You are part of a ufoo multi-agent group.",
   "",
@@ -13,6 +22,8 @@ const SHARED_GROUP_PREFIX = [
   "- When reporting, separate facts, inferences, and recommendations.",
   "- Preserve continuity with the group's current task rather than restarting analysis from scratch.",
   "",
+  SHARED_UFOO_PROTOCOL,
+  "",
   "Coordination protocol:",
   "- Use direct handoff for worker-to-worker delivery.",
   "- Use private `ufoo report` updates for ufoo-agent control-plane reporting.",
@@ -28,6 +39,8 @@ const SOLO_AGENT_PREFIX = [
   "- Surface uncertainty explicitly.",
   "- Preserve continuity with the current task instead of restarting from scratch.",
   "- Use ufoo-agent for control-plane coordination, not as a substitute for doing your role.",
+  "",
+  SHARED_UFOO_PROTOCOL,
 ].join("\n");
 
 function asTrimmedString(value) {
@@ -145,6 +158,7 @@ function computeBootstrapFingerprint({
 }
 
 module.exports = {
+  SHARED_UFOO_PROTOCOL,
   SHARED_GROUP_PREFIX,
   SOLO_AGENT_PREFIX,
   buildGroupPromptMetadata,

package/src/group/promptProfiles.js

@@ -352,6 +352,38 @@ const BUILTIN_PROFILES = [
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
+  {
+    id: "pmo-coordinator",
+    display_name: "PMO",
+    short_name: "PMO",
+    aliases: ["pmo"],
+    summary: "Coordinate execution across builders, track progress, unblock dependencies, and enforce delivery cadence.",
+    prompt: [
+      "You are the PMO coordinator for this ufoo group.",
+      "",
+      "Mission:",
+      "- Coordinate execution across multiple builders to maximize throughput and minimize idle time.",
+      "- Track progress, surface blockers early, enforce delivery cadence, and keep the team aligned on priorities.",
+      "",
+      "Boundaries:",
+      "- Do not make architectural or scope decisions — escalate to architect or scope challenger.",
+      "- Do not write production code.",
+      "- Do not reorder priorities without naming the tradeoff and notifying affected agents.",
+      "",
+      "Method:",
+      "- Assign slices to builders based on dependency order and current load.",
+      "- Monitor builder progress and proactively unblock stalled work.",
+      "- Maintain a clear view of what is done, in-flight, and blocked at all times.",
+      "- Enforce review gates — no slice ships without reviewer sign-off.",
+      "- Batch related changes when possible to reduce review churn.",
+      "",
+      "Handoff:",
+      "- Send execution-ready slices to builders with clear acceptance criteria.",
+      "- Send completed work to reviewer with context on what changed and why.",
+      "- Escalate blockers to architect or the human operator.",
+      "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
+    ].join("\n"),
+  },
   {
     id: "rapid-prototype",
     display_name: "Prototype",

package/src/solo/commands.js

@@ -0,0 +1,31 @@
+"use strict";
+
+function asTrimmedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function resolveSoloAgentType(config = {}, requestedAgent = "") {
+  const requested = asTrimmedString(requestedAgent).toLowerCase();
+  if (requested === "claude" || requested === "uclaude" || requested === "claude-code") return "claude";
+  if (requested === "codex" || requested === "ucodex" || requested === "openai") return "codex";
+  if (requested === "ucode" || requested === "ufoo" || requested === "ufoo-code") return "ucode";
+
+  const provider = asTrimmedString(config && config.agentProvider).toLowerCase();
+  if (provider === "claude-cli") return "claude";
+  if (provider === "ucode") return "ucode";
+  return "codex";
+}
+
+function buildPromptProfileCandidates(registry = null) {
+  const profiles = Array.isArray(registry && registry.profiles) ? registry.profiles : [];
+  return profiles.map((item) => ({
+    cmd: item.id,
+    desc: [item.summary || "", item.source || ""].filter(Boolean).join(" · "),
+    source: item.source || "",
+  }));
+}
+
+module.exports = {
+  resolveSoloAgentType,
+  buildPromptProfileCandidates,
+};

package/templates/groups/build-ultra.json

@@ -0,0 +1,225 @@
+{
+  "schema_version": 1,
+  "template": {
+    "id": "build-ultra",
+    "alias": "build-ultra",
+    "name": "Build Ultra"
+  },
+  "defaults": {
+    "launch_mode": "auto",
+    "start_timeout_ms": 30000
+  },
+  "agents": [
+    {
+      "id": "pmo",
+      "nickname": "pmo",
+      "type": "auto",
+      "role": "coordinate builders, track progress, enforce delivery cadence",
+      "prompt_profile": "pmo-coordinator",
+      "accept_from": [
+        "builder-1",
+        "builder-2",
+        "builder-3",
+        "builder-4",
+        "reviewer"
+      ],
+      "report_to": [
+        "builder-1",
+        "builder-2",
+        "builder-3",
+        "builder-4",
+        "reviewer"
+      ],
+      "startup_order": 1,
+      "depends_on": []
+    },
+    {
+      "id": "builder-1",
+      "nickname": "builder-1",
+      "type": "auto",
+      "role": "implement approved slices",
+      "prompt_profile": "implementation-lead",
+      "accept_from": [
+        "pmo",
+        "reviewer"
+      ],
+      "report_to": [
+        "pmo",
+        "reviewer"
+      ],
+      "startup_order": 2,
+      "depends_on": [
+        "pmo"
+      ]
+    },
+    {
+      "id": "builder-2",
+      "nickname": "builder-2",
+      "type": "auto",
+      "role": "implement approved slices",
+      "prompt_profile": "implementation-lead",
+      "accept_from": [
+        "pmo",
+        "reviewer"
+      ],
+      "report_to": [
+        "pmo",
+        "reviewer"
+      ],
+      "startup_order": 2,
+      "depends_on": [
+        "pmo"
+      ]
+    },
+    {
+      "id": "builder-3",
+      "nickname": "builder-3",
+      "type": "auto",
+      "role": "implement approved slices",
+      "prompt_profile": "implementation-lead",
+      "accept_from": [
+        "pmo",
+        "reviewer"
+      ],
+      "report_to": [
+        "pmo",
+        "reviewer"
+      ],
+      "startup_order": 2,
+      "depends_on": [
+        "pmo"
+      ]
+    },
+    {
+      "id": "builder-4",
+      "nickname": "builder-4",
+      "type": "auto",
+      "role": "implement approved slices",
+      "prompt_profile": "implementation-lead",
+      "accept_from": [
+        "pmo",
+        "reviewer"
+      ],
+      "report_to": [
+        "pmo",
+        "reviewer"
+      ],
+      "startup_order": 2,
+      "depends_on": [
+        "pmo"
+      ]
+    },
+    {
+      "id": "reviewer",
+      "nickname": "reviewer",
+      "type": "auto",
+      "role": "review correctness and risk",
+      "prompt_profile": "review-critic",
+      "accept_from": [
+        "pmo",
+        "builder-1",
+        "builder-2",
+        "builder-3",
+        "builder-4"
+      ],
+      "report_to": [
+        "pmo",
+        "builder-1",
+        "builder-2",
+        "builder-3",
+        "builder-4"
+      ],
+      "startup_order": 3,
+      "depends_on": [
+        "pmo"
+      ]
+    }
+  ],
+  "edges": [
+    {
+      "from": "pmo",
+      "to": "builder-1",
+      "kind": "task"
+    },
+    {
+      "from": "pmo",
+      "to": "builder-2",
+      "kind": "task"
+    },
+    {
+      "from": "pmo",
+      "to": "builder-3",
+      "kind": "task"
+    },
+    {
+      "from": "pmo",
+      "to": "builder-4",
+      "kind": "task"
+    },
+    {
+      "from": "builder-1",
+      "to": "reviewer",
+      "kind": "review"
+    },
+    {
+      "from": "builder-2",
+      "to": "reviewer",
+      "kind": "review"
+    },
+    {
+      "from": "builder-3",
+      "to": "reviewer",
+      "kind": "review"
+    },
+    {
+      "from": "builder-4",
+      "to": "reviewer",
+      "kind": "review"
+    },
+    {
+      "from": "reviewer",
+      "to": "builder-1",
+      "kind": "task"
+    },
+    {
+      "from": "reviewer",
+      "to": "builder-2",
+      "kind": "task"
+    },
+    {
+      "from": "reviewer",
+      "to": "builder-3",
+      "kind": "task"
+    },
+    {
+      "from": "reviewer",
+      "to": "builder-4",
+      "kind": "task"
+    },
+    {
+      "from": "reviewer",
+      "to": "pmo",
+      "kind": "report"
+    },
+    {
+      "from": "builder-1",
+      "to": "pmo",
+      "kind": "report"
+    },
+    {
+      "from": "builder-2",
+      "to": "pmo",
+      "kind": "report"
+    },
+    {
+      "from": "builder-3",
+      "to": "pmo",
+      "kind": "report"
+    },
+    {
+      "from": "builder-4",
+      "to": "pmo",
+      "kind": "report"
+    }
+  ]
+}