u-foo 1.2.16 → 1.4.0

package/modules/online/README.md

@@ -55,6 +55,24 @@ In private room mode, agents automatically sync:
 - **Decisions** — new `.md` files synced across team
 - **Wake events** — remote agent can wake local agent via bus
 
+## HTTP APIs (for web preview)
+
+Auth-required management APIs:
+
+- `GET/POST /ufoo/online/channels`
+- `GET/POST /ufoo/online/rooms`
+
+Public read-only preview APIs (no bearer token required):
+
+- `GET /ufoo/online/public/channels`
+- `GET /ufoo/online/public/rooms?type=private`
+- `GET /ufoo/online/public/channels/:channel/messages?limit=120`
+
+Notes:
+
+- Channel history is in-memory (rolling buffer) on relay server.
+- Private room public API only exposes metadata (`room_id`, `name`, `created_by`, `password_required`).
+
 ## Storage
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.2.16",
+  "version": "1.4.0",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",
@@ -27,6 +27,7 @@
   "files": [
     "bin/",
     "src/",
+    "templates/",
     "online/",
     "scripts/",
     "SKILLS/",

package/src/agent/cliRunner.js

@@ -678,7 +678,7 @@ async function runCliAgent(params) {
           cwd: params.cwd,
           env,
           input: retryStdin,
-          timeoutMs: params.timeoutMs || 60000,
+          timeoutMs: params.timeoutMs || 300000,
           onStdout: retryParser ? (chunk) => retryParser.onChunk(chunk) : null,
           signal: params.signal,
         });

package/src/agent/launcher.js

@@ -522,6 +522,13 @@ class AgentLauncher {
           // 当检测到agent ready时，通知daemon可以提前inject probe
           const daemonSockPath = getUfooPaths(this.cwd).ufooSock;
           readyDetector.onReady(async () => {
+            // Claude Code's Ink TUI renders ❯ prompt before the input handler
+            // is fully mounted. Wait a short period for the TUI to be ready to
+            // accept injected text, otherwise only the trailing CR is processed
+            // and the probe command is lost.
+            if (this.agentType === "claude-code") {
+              await new Promise((r) => setTimeout(r, 800));
+            }
             const startTime = Date.now();
             try {
               const daemonSock = await connectWithRetry(daemonSockPath, 3, 100);
@@ -648,13 +655,25 @@ 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.
                     wrapper.write(req.command);
-                    setTimeout(() => {
-                      wrapper.write("\x1b");
+                    if (normalizedAgentType === "claude-code") {
+                      // Claude Code: send CR directly without ESC.
+                      // ESC before CR is interpreted as Alt+Enter (newline).
                       setTimeout(() => {
                         wrapper.write("\r");
-                      }, 100);
-                    }, 200);
+                      }, 200);
+                    } else {
+                      // Codex/others: ESC dismisses autocomplete, then CR submits.
+                      setTimeout(() => {
+                        wrapper.write("\x1b");
+                        setTimeout(() => {
+                          wrapper.write("\r");
+                        }, 100);
+                      }, 200);
+                    }
                     client.write(JSON.stringify({ ok: true }) + "\n");
                     if (wrapper.logger) {
                       const logEntry = {

package/src/agent/ptyRunner.js

@@ -332,16 +332,28 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
             const req = JSON.parse(line);
             if (req.type === "inject" && req.command) {
               if (ptyProcess && ptyAlive) {
+                const isClaude = agentType === "claude-code";
                 ptyProcess.write(String(req.command));
-                setTimeout(() => {
-                  if (!ptyProcess || !ptyAlive) return;
-                  ptyProcess.write("\x1b");
+                if (isClaude) {
+                  // Claude Code: send CR directly without ESC.
+                  // ESC before CR is interpreted as Alt+Enter (newline).
                   setTimeout(() => {
                     if (ptyProcess && ptyAlive) {
                       ptyProcess.write("\r");
                     }
-                  }, 100);
-                }, 200);
+                  }, 200);
+                } else {
+                  // Codex/others: ESC dismisses autocomplete, then CR submits.
+                  setTimeout(() => {
+                    if (!ptyProcess || !ptyAlive) return;
+                    ptyProcess.write("\x1b");
+                    setTimeout(() => {
+                      if (ptyProcess && ptyAlive) {
+                        ptyProcess.write("\r");
+                      }
+                    }, 100);
+                  }, 200);
+                }
                 client.write(JSON.stringify({ ok: true }) + "\n");
               } else {
                 client.write(JSON.stringify({ ok: false, error: "pty not ready" }) + "\n");
@@ -744,16 +756,11 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
         setTimeout(() => {
           if (ptyProcess && ptyAlive) {
             outputBuffer = "";
-            // Send ESC first to dismiss any auto-complete/suggestion overlay
-            // in Ink-based TUIs (Claude Code, Codex), then CR to submit.
-            // This matches the inject socket pattern in launcher.js.
-            ptyProcess.write("\x1b");
-            setTimeout(() => {
-              if (ptyProcess && ptyAlive) {
-                ptyProcess.write("\r");
-              }
-              // Fallback: if we never observe the marker in echoed output,
-              // stop suppressing after a short delay to avoid freezing output.
+            const isClaude = agentType === "claude-code";
+            if (isClaude) {
+              // Claude Code: send CR directly without ESC.
+              // ESC before CR is interpreted as Alt+Enter (newline).
+              ptyProcess.write("\r");
               suppressTimer = setTimeout(() => {
                 suppressTimer = null;
                 if (!suppressEcho) return;
@@ -762,7 +769,23 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
                 currentMarker = savedMarker;
                 outputBuffer = "";
               }, 1500);
-            }, 100);
+            } else {
+              // Codex/others: ESC dismisses autocomplete, then CR submits.
+              ptyProcess.write("\x1b");
+              setTimeout(() => {
+                if (ptyProcess && ptyAlive) {
+                  ptyProcess.write("\r");
+                }
+                suppressTimer = setTimeout(() => {
+                  suppressTimer = null;
+                  if (!suppressEcho) return;
+                  suppressEcho = false;
+                  echoMarker = "";
+                  currentMarker = savedMarker;
+                  outputBuffer = "";
+                }, 1500);
+              }, 100);
+            }
           }
         }, 200);
       }

package/src/agent/ufooAgent.js

@@ -9,6 +9,7 @@ const {
   resolveCompletionUrl,
   resolveAnthropicMessagesUrl,
 } = require("../code/nativeRunner");
+const { DEFAULT_ASSISTANT_TIMEOUT_MS } = require("../assistant/constants");
 
 function loadSessionState(projectRoot) {
   const dir = getUfooPaths(projectRoot).agentDir;
@@ -89,7 +90,7 @@ function buildSystemPrompt(context) {
     "Schema:",
     "{",
     '  "reply": "string",',
-    '  "assistant_call": {"kind":"explore|bash|mixed","task":"string","context":"optional","expect":"optional","provider":"codex|claude|ufoo (optional)","model":"optional","timeout_ms":60000},',
+    `  "assistant_call": {"kind":"explore|bash|mixed","task":"string","context":"optional","expect":"optional","provider":"codex|claude|ufoo (optional)","model":"optional","timeout_ms":${DEFAULT_ASSISTANT_TIMEOUT_MS}},`,
     '  "dispatch": [{"target":"broadcast|<agent-id>|<nickname>","message":"string"}],',
     '  "ops": [{"action":"launch|close|rename|cron","agent":"codex|claude|ucode","count":1,"agent_id":"id","nickname":"optional","operation":"start|list|stop","every":"30m","interval_ms":1800000,"target":"agent-id|nickname|csv","targets":["agent-id"],"prompt":"message","id":"task-id|all"}],',
     '  "disambiguate": {"prompt":"string","candidates":[{"agent_id":"id","reason":"string"}]}',

package/src/assistant/agent.js

@@ -3,6 +3,7 @@ const path = require("path");
 const { runCliAgent } = require("../agent/cliRunner");
 const { normalizeCliOutput } = require("../agent/normalizeOutput");
 const { resolveAssistantEngine, runExternalAssistantEngine } = require("./engine");
+const { DEFAULT_ASSISTANT_TIMEOUT_MS, normalizeAssistantTimeoutMs } = require("./constants");
 const { getUfooPaths } = require("../ufoo/paths");
 
 const ASSISTANT_JSON_SCHEMA = {
@@ -36,7 +37,7 @@ function parseTaskPayload(payload = {}) {
   const kind = typeof payload.kind === "string" && payload.kind ? payload.kind : "mixed";
   const context = typeof payload.context === "string" ? payload.context : "";
   const expectText = typeof payload.expect === "string" ? payload.expect : "";
-  const timeoutMs = Number.isFinite(payload.timeout_ms) ? payload.timeout_ms : 60000;
+  const timeoutMs = normalizeAssistantTimeoutMs(payload.timeout_ms, DEFAULT_ASSISTANT_TIMEOUT_MS);
 
   return {
     projectRoot,

package/src/assistant/bridge.js

@@ -1,5 +1,10 @@
 const { spawn } = require("child_process");
 const path = require("path");
+const {
+  DEFAULT_ASSISTANT_TIMEOUT_MS,
+  DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS,
+  normalizeAssistantTimeoutMs,
+} = require("./constants");
 
 function resolveAssistantCommand() {
   const raw = String(process.env.UFOO_ASSISTANT_CMD || "ufoo-assistant-agent").trim();
@@ -70,10 +75,11 @@ async function runAssistantTask({
   kind = "mixed",
   context = "",
   expect = "",
-  timeoutMs = 60000,
+  timeoutMs = DEFAULT_ASSISTANT_TIMEOUT_MS,
 } = {}) {
   return new Promise((resolve) => {
     const startedAt = Date.now();
+    const effectiveTimeoutMs = normalizeAssistantTimeoutMs(timeoutMs, DEFAULT_ASSISTANT_TIMEOUT_MS);
     const { command, args } = resolveAssistantCommand();
     const payload = {
       request_id: `assistant-${startedAt}`,
@@ -85,7 +91,7 @@ async function runAssistantTask({
       kind,
       context,
       expect,
-      timeout_ms: timeoutMs,
+      timeout_ms: effectiveTimeoutMs,
     };
 
     const child = spawn(command, args, {
@@ -117,7 +123,7 @@ async function runAssistantTask({
         error: "assistant timeout",
         metrics: { duration_ms: Date.now() - startedAt },
       });
-    }, timeoutMs);
+    }, effectiveTimeoutMs + DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS);
 
     child.on("error", (err) => {
       clearTimeout(timer);

package/src/assistant/constants.js

@@ -0,0 +1,15 @@
+const DEFAULT_ASSISTANT_TIMEOUT_MS = 300000; // 5 minutes
+const DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS = 5000;
+
+function normalizeAssistantTimeoutMs(value, fallback = DEFAULT_ASSISTANT_TIMEOUT_MS) {
+  const parsed = Number(value);
+  const base = Number.isFinite(parsed) ? parsed : fallback;
+  if (!Number.isFinite(base)) return DEFAULT_ASSISTANT_TIMEOUT_MS;
+  return Math.max(1000, Math.floor(base));
+}
+
+module.exports = {
+  DEFAULT_ASSISTANT_TIMEOUT_MS,
+  DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS,
+  normalizeAssistantTimeoutMs,
+};

package/src/assistant/engine.js

@@ -1,5 +1,6 @@
 const { spawn } = require("child_process");
 const { loadConfig, normalizeAssistantEngine } = require("../config");
+const { DEFAULT_ASSISTANT_TIMEOUT_MS, normalizeAssistantTimeoutMs } = require("./constants");
 
 function splitCommand(raw, fallback = "ufoo-engine") {
   const text = String(raw || "").trim();
@@ -103,6 +104,9 @@ function buildExternalEngineArgs(engine = {}, payload = {}) {
   if (payload.kind) args.push("--kind", String(payload.kind));
   if (payload.context) args.push("--context", String(payload.context));
   if (payload.expect) args.push("--expect", String(payload.expect));
+  if (Number.isFinite(payload.timeout_ms)) {
+    args.push("--timeout-ms", String(normalizeAssistantTimeoutMs(payload.timeout_ms)));
+  }
   args.push(String(payload.task || ""));
   return args;
 }
@@ -115,9 +119,10 @@ function extractSessionId(parsed) {
 async function runExternalAssistantEngine({
   engine,
   payload,
-  timeoutMs = 60000,
+  timeoutMs = DEFAULT_ASSISTANT_TIMEOUT_MS,
 }) {
   const startedAt = Date.now();
+  const effectiveTimeoutMs = normalizeAssistantTimeoutMs(timeoutMs, DEFAULT_ASSISTANT_TIMEOUT_MS);
 
   const runAttempt = (attempt = {}) => new Promise((resolve) => {
     const child = spawn(engine.command, attempt.args || [], {
@@ -149,7 +154,7 @@ async function runExternalAssistantEngine({
         stderr,
         error: "assistant engine timeout",
       });
-    }, timeoutMs);
+    }, effectiveTimeoutMs);
 
     child.on("error", (err) => {
       clearTimeout(timer);

package/src/assistant/ufooEngineCli.js

@@ -1,6 +1,7 @@
 const { runCliAgent } = require("../agent/cliRunner");
 const { normalizeCliOutput } = require("../agent/normalizeOutput");
 const { loadConfig } = require("../config");
+const { DEFAULT_ASSISTANT_TIMEOUT_MS, normalizeAssistantTimeoutMs } = require("./constants");
 
 function normalizeProvider(value, fallback = "codex-cli") {
   const raw = String(value || "").trim().toLowerCase();
@@ -21,6 +22,7 @@ function parseAssistantTaskArgs(argv = []) {
     kind: "mixed",
     context: "",
     expect: "",
+    timeoutMs: DEFAULT_ASSISTANT_TIMEOUT_MS,
     task: "",
   };
 
@@ -64,6 +66,10 @@ function parseAssistantTaskArgs(argv = []) {
       options.expect = args[++i] || "";
       continue;
     }
+    if (arg === "--timeout-ms") {
+      options.timeoutMs = normalizeAssistantTimeoutMs(args[++i], DEFAULT_ASSISTANT_TIMEOUT_MS);
+      continue;
+    }
     rest.push(arg);
   }
   options.task = rest.join(" ").trim();
@@ -187,7 +193,7 @@ async function runEngineTask(taskInput, deps = {}) {
     task: taskInput.task,
     expect: taskInput.expect,
   });
-  const timeoutMs = Number.isFinite(taskInput.timeoutMs) ? taskInput.timeoutMs : 60000;
+  const timeoutMs = normalizeAssistantTimeoutMs(taskInput.timeoutMs, DEFAULT_ASSISTANT_TIMEOUT_MS);
 
   const runOnce = async (sessionId) => runCliAgentImpl({
     provider,
@@ -257,7 +263,7 @@ async function runUfooEngineCli({ argv = [], stdinText = "", deps = {} } = {}) {
       model: options.model,
       sessionId: options.sessionId,
       cwd: options.cwd,
-      timeoutMs: 60000,
+      timeoutMs: normalizeAssistantTimeoutMs(options.timeoutMs, DEFAULT_ASSISTANT_TIMEOUT_MS),
     };
   } else {
     const payload = parseStdinPayload(stdinText);
@@ -281,7 +287,7 @@ async function runUfooEngineCli({ argv = [], stdinText = "", deps = {} } = {}) {
       model: typeof payload.model === "string" ? payload.model : "",
       sessionId: typeof payload.session_id === "string" ? payload.session_id : "",
       cwd: typeof payload.project_root === "string" ? payload.project_root : "",
-      timeoutMs: Number.isFinite(payload.timeout_ms) ? payload.timeout_ms : 60000,
+      timeoutMs: normalizeAssistantTimeoutMs(payload.timeout_ms, DEFAULT_ASSISTANT_TIMEOUT_MS),
     };
   }
 

package/src/chat/commandExecutor.js

@@ -2,6 +2,7 @@ const path = require("path");
 const EventBus = require("../bus");
 const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
 const UfooInit = require("../init");
+const { runGroupCoreCommand } = require("../cli/groupCoreCommands");
 const { loadConfig: loadProjectConfig, saveConfig: saveProjectConfig, loadGlobalUcodeConfig, saveGlobalUcodeConfig } = require("../config");
 const { resolveTransport } = require("../code/nativeRunner");
 const { parseIntervalMs, formatIntervalMs } = require("./cronScheduler");
@@ -69,6 +70,7 @@ function createCommandExecutor(options = {}) {
     createCronTask = () => null,
     listCronTasks = () => [],
     stopCronTask = () => false,
+    runGroupCore = runGroupCoreCommand,
     requestCron = null,
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     schedule = (fn, ms) => setTimeout(fn, ms),
@@ -381,8 +383,6 @@ function createCommandExecutor(options = {}) {
     }
 
     try {
-      const label = nickname ? ` (${nickname})` : "";
-      logMessage("system", `{white-fg}⚙{/white-fg} Launching ${normalizedAgent}${label}...`);
       send({
         type: IPC_REQUEST_TYPES.LAUNCH_AGENT,
         agent: normalizedAgent,
@@ -413,6 +413,19 @@ function createCommandExecutor(options = {}) {
     schedule(requestStatus, 1000);
   }
 
+  function parseKeyValueArgs(args = []) {
+    const parsed = {};
+    for (const raw of args) {
+      if (!raw || !String(raw).includes("=")) continue;
+      const [keyRaw, ...valueParts] = String(raw).split("=");
+      const key = String(keyRaw || "").trim().toLowerCase();
+      const value = valueParts.join("=").trim();
+      if (!key) continue;
+      parsed[key] = value;
+    }
+    return parsed;
+  }
+
   function parseCronTargets(raw = "") {
     return String(raw || "")
       .split(",")
@@ -499,7 +512,7 @@ function createCommandExecutor(options = {}) {
     }
 
     const startArgs = action === "start" ? args.slice(1) : args;
-    const kv = parseUcodeConfigKv(startArgs);
+    const kv = parseKeyValueArgs(startArgs);
     const nonKvParts = startArgs.filter((item) => !String(item || "").includes("="));
 
     const intervalRaw = String(
@@ -598,6 +611,173 @@ function createCommandExecutor(options = {}) {
     );
   }
 
+  function parseBooleanOption(value, fallback = false) {
+    const text = String(value || "").trim().toLowerCase();
+    if (!text) return fallback;
+    if (text === "1" || text === "true" || text === "yes" || text === "y" || text === "on") return true;
+    if (text === "0" || text === "false" || text === "no" || text === "n" || text === "off") return false;
+    return fallback;
+  }
+
+  function logGroupCoreOutput(text) {
+    const lines = String(text || "").split(/\r?\n/);
+    lines.forEach((line) => {
+      logMessage("system", escapeBlessed(line));
+    });
+  }
+
+  async function handleGroupCommand(args = []) {
+    const subcommand = String(args[0] || "").trim().toLowerCase();
+    if (!subcommand) {
+      logMessage(
+        "error",
+        "{white-fg}✗{/white-fg} Usage: /group <templates|template|run|status|stop|diagram> ..."
+      );
+      return;
+    }
+
+    if (subcommand === "templates") {
+      const action = String(args[1] || "list").trim().toLowerCase();
+      if (action !== "list" && action !== "ls") {
+        logMessage("error", `{white-fg}✗{/white-fg} Unknown group templates action: ${escapeBlessed(action)}`);
+        return;
+      }
+      try {
+        await runGroupCore("templates", [action], {
+          cwd: projectRoot,
+          write: logGroupCoreOutput,
+        });
+      } catch (err) {
+        logMessage("error", `{white-fg}✗{/white-fg} Group templates failed: ${escapeBlessed(err.message)}`);
+      }
+      return;
+    }
+
+    if (subcommand === "template") {
+      const action = String(args[1] || "list").trim().toLowerCase();
+      if (action === "validate") {
+        const target = String(args[2] || "").trim();
+        if (!target) {
+          logMessage("error", "{white-fg}✗{/white-fg} Usage: /group template validate <alias|path>");
+          return;
+        }
+        send({
+          type: IPC_REQUEST_TYPES.GROUP_TEMPLATE_VALIDATE,
+          target,
+          alias: target,
+          path: target,
+        });
+        return;
+      }
+      try {
+        await runGroupCore("template", [action, ...args.slice(2)], {
+          cwd: projectRoot,
+          write: logGroupCoreOutput,
+        });
+      } catch (err) {
+        logMessage("error", `{white-fg}✗{/white-fg} Group template failed: ${escapeBlessed(err.message)}`);
+      }
+      return;
+    }
+
+    if (subcommand === "run") {
+      const alias = String(args[1] || "").trim();
+      if (!alias) {
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /group run <alias> [instance=<name>] [dry_run=true]");
+        return;
+      }
+      const runArgs = args.slice(2);
+      const kv = parseKeyValueArgs(runArgs);
+      let instance = String(kv.instance || kv.group_id || "").trim();
+      const instanceIndex = runArgs.indexOf("--instance");
+      if (instanceIndex !== -1) {
+        instance = String(runArgs[instanceIndex + 1] || "").trim();
+      }
+      let dryRun = runArgs.includes("--dry-run");
+      if (!dryRun && Object.prototype.hasOwnProperty.call(kv, "dry_run")) {
+        dryRun = parseBooleanOption(kv.dry_run, false);
+      }
+      if (!dryRun && Object.prototype.hasOwnProperty.call(kv, "dryrun")) {
+        dryRun = parseBooleanOption(kv.dryrun, false);
+      }
+      send({
+        type: IPC_REQUEST_TYPES.LAUNCH_GROUP,
+        alias,
+        instance,
+        dry_run: dryRun,
+      });
+      schedule(requestStatus, 1000);
+      return;
+    }
+
+    if (subcommand === "status") {
+      const statusArgs = args.slice(1);
+      const kv = parseKeyValueArgs(statusArgs);
+      const groupId = String(
+        kv.group_id ||
+        kv.group ||
+        (statusArgs[0] && !String(statusArgs[0]).includes("=") ? statusArgs[0] : "")
+      ).trim();
+      send({
+        type: IPC_REQUEST_TYPES.GROUP_STATUS,
+        group_id: groupId,
+      });
+      return;
+    }
+
+    if (subcommand === "stop") {
+      const stopArgs = args.slice(1);
+      const kv = parseKeyValueArgs(stopArgs);
+      const groupId = String(
+        kv.group_id ||
+        kv.group ||
+        (stopArgs[0] && !String(stopArgs[0]).includes("=") ? stopArgs[0] : "")
+      ).trim();
+      if (!groupId) {
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /group stop <groupId>");
+        return;
+      }
+      send({
+        type: IPC_REQUEST_TYPES.STOP_GROUP,
+        group_id: groupId,
+      });
+      schedule(requestStatus, 1000);
+      return;
+    }
+
+    if (subcommand === "diagram") {
+      const diagramArgs = args.slice(1);
+      const kv = parseKeyValueArgs(diagramArgs);
+      const target = String(
+        kv.group_id ||
+        kv.group ||
+        kv.alias ||
+        (diagramArgs[0] && !String(diagramArgs[0]).includes("=") ? diagramArgs[0] : "")
+      ).trim();
+      if (!target) {
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /group diagram <alias|groupId> [format=ascii|mermaid]");
+        return;
+      }
+      const format = diagramArgs.includes("--mermaid")
+        ? "mermaid"
+        : (diagramArgs.includes("--ascii")
+          ? "ascii"
+          : String(kv.format || "ascii").trim().toLowerCase());
+      send({
+        type: IPC_REQUEST_TYPES.GROUP_DIAGRAM,
+        alias: target,
+        group_id: target,
+        format: format === "mermaid" ? "mermaid" : "ascii",
+      });
+      return;
+    }
+
+    logMessage(
+      "error",
+      "{white-fg}✗{/white-fg} Unknown group command. Use: templates, template, run, status, stop, diagram"
+    );
+  }
+
   async function handleSettingsCommand(args = []) {
     const section = String(args[0] || "").trim().toLowerCase();
     if (!section) {
@@ -619,16 +799,7 @@ function createCommandExecutor(options = {}) {
   }
 
   function parseUcodeConfigKv(args = []) {
-    const parsed = {};
-    for (const raw of args) {
-      if (!raw || !String(raw).includes("=")) continue;
-      const [keyRaw, ...valueParts] = String(raw).split("=");
-      const key = String(keyRaw || "").trim().toLowerCase();
-      const value = valueParts.join("=").trim();
-      if (!key) continue;
-      parsed[key] = value;
-    }
-    return parsed;
+    return parseKeyValueArgs(args);
   }
 
   function maskSecret(value = "") {
@@ -795,6 +966,9 @@ function createCommandExecutor(options = {}) {
       case "cron":
         await handleCronCommand(args);
         return true;
+      case "group":
+        await handleGroupCommand(args);
+        return true;
       case "settings":
         await handleSettingsCommand(args);
         return true;
@@ -819,6 +993,7 @@ function createCommandExecutor(options = {}) {
     handleLaunchCommand,
     handleResumeCommand,
     handleCronCommand,
+    handleGroupCommand,
     handleSettingsCommand,
     handleUcodeConfigCommand,
     handleUfooCommand,

package/src/chat/commands.js

@@ -35,6 +35,17 @@ const COMMAND_TREE = {
       stop: { desc: "Stop cron task by id or all" },
     },
   },
+  "/group": {
+    desc: "Agent group orchestration",
+    children: {
+      diagram: { desc: "Render group diagram (ascii|mermaid)" },
+      run: { desc: "Launch a group template" },
+      status: { desc: "Show group runtime status" },
+      stop: { desc: "Stop a running group" },
+      template: { desc: "Template ops (list/show/validate/new)" },
+      templates: { desc: "List available templates" },
+    },
+  },
   "/init": { desc: "Initialize modules" },
   "/launch": {
     desc: "Launch new agent",