u-foo 2.2.0 → 2.2.2

package/package.json

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

package/src/bus/store.js

@@ -15,19 +15,6 @@ function readQueueTty(queueDir) {
   }
 }
 
-function nicknamePrefixForType(agentType = "") {
-  return agentType === "claude-code" ? "claude"
-       : agentType === "ufoo-code" ? "ucode"
-       : String(agentType || "agent");
-}
-
-function isRecoverableSessionId(sessionId = "") {
-  const text = String(sessionId || "").trim();
-  if (!text) return false;
-  if (text.includes(":") || text.includes("_")) return false;
-  return true;
-}
-
 function buildUsedNicknameSet(agents = {}) {
   const set = new Set();
   for (const meta of Object.values(agents || {})) {
@@ -38,15 +25,6 @@ function buildUsedNicknameSet(agents = {}) {
   return set;
 }
 
-function allocateRecoveredNickname(agentType, used) {
-  const prefix = nicknamePrefixForType(agentType);
-  let idx = 1;
-  while (used.has(`${prefix}-${idx}`)) idx += 1;
-  const nick = `${prefix}-${idx}`;
-  used.add(nick);
-  return nick;
-}
-
 function recoverQueueEntry(data, subscriber, queueDir, usedNicknames, now) {
   if (!subscriber || data.agents[subscriber]) return false;
 
@@ -67,31 +45,7 @@ function recoverQueueEntry(data, subscriber, queueDir, usedNicknames, now) {
     };
     return true;
   }
-
-  const parts = subscriber.split(":");
-  if (parts.length !== 2) return false;
-  const [agentType, sessionId] = parts;
-  if (!agentType || !sessionId) return false;
-  if (!isRecoverableSessionId(sessionId)) return false;
-
-  const tty = readQueueTty(queueDir);
-  const ttyInfo = tty ? getTtyProcessInfo(tty) : null;
-  const activeByTty = Boolean(ttyInfo && ttyInfo.alive && ttyInfo.hasAgent);
-  const nickname = activeByTty ? allocateRecoveredNickname(agentType, usedNicknames) : "";
-
-  data.agents[subscriber] = {
-    agent_type: agentType,
-    nickname,
-    status: activeByTty ? "active" : "inactive",
-    joined_at: now,
-    last_seen: now,
-    pid: 0,
-    tty,
-    tty_shell_pid: ttyInfo && ttyInfo.shellPid ? ttyInfo.shellPid : 0,
-    tmux_pane: "",
-    launch_mode: "",
-  };
-  return true;
+  return false;
 }
 
 function reconcileReservedControllerAliases(data, now) {

package/src/bus/subscriber.js

@@ -98,6 +98,30 @@ class SubscriberManager {
     this.queueManager = queueManager;
   }
 
+  cleanupSubscriberArtifacts(subscriber) {
+    if (!subscriber || !this.queueManager) return;
+    try {
+      const queueDir = this.queueManager.getQueueDir
+        ? this.queueManager.getQueueDir(subscriber)
+        : "";
+      if (queueDir) {
+        fs.rmSync(queueDir, { recursive: true, force: true });
+      }
+    } catch {
+      // ignore cleanup errors
+    }
+    try {
+      const offsetPath = this.queueManager.getOffsetPath
+        ? this.queueManager.getOffsetPath(subscriber)
+        : "";
+      if (offsetPath) {
+        fs.rmSync(offsetPath, { force: true });
+      }
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+
   async cleanupDuplicateTty(currentSubscriber, ttyPath) {
     if (!ttyPath) return null;
     if (!this.busData.agents) return null;
@@ -301,6 +325,7 @@ class SubscriberManager {
     this.busData.agents[subscriber].status = "inactive";
     this.busData.agents[subscriber].activity_state = "";
     this.busData.agents[subscriber].last_seen = getTimestamp();
+    this.cleanupSubscriberArtifacts(subscriber);
 
     return true;
   }
@@ -364,6 +389,7 @@ class SubscriberManager {
         meta.status = "inactive";
         meta.activity_state = "";
         meta.last_seen = getTimestamp();
+        this.cleanupSubscriberArtifacts(id);
       }
     }
   }

package/src/chat/commandExecutor.js

@@ -3,7 +3,13 @@ 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 {
+  loadConfig: loadProjectConfig,
+  saveConfig: saveProjectConfig,
+  loadGlobalUcodeConfig,
+  saveGlobalUcodeConfig,
+  normalizeControllerMode,
+} = require("../config");
 const { resolveTransport } = require("../code/nativeRunner");
 const { parseIntervalMs, formatIntervalMs } = require("./cronScheduler");
 const { isGlobalControllerProjectRoot, resolveGlobalControllerUfooDir } = require("../projects");
@@ -1104,10 +1110,10 @@ function createCommandExecutor(options = {}) {
         kv.group_id ||
         kv.group ||
         kv.alias ||
-        (diagramArgs[0] && !String(diagramArgs[0]).includes("=") ? diagramArgs[0] : "")
+        (diagramArgs[0] && !String(diagramArgs[0]).includes("=") ? diagramArgs[0] : "current")
       ).trim();
       if (!target) {
-        logMessage("error", "{white-fg}✗{/white-fg} Usage: /group diagram <alias|groupId> [format=ascii|mermaid]");
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /group diagram [current|alias|groupId] [format=ascii|mermaid]");
         return;
       }
       const format = diagramArgs.includes("--mermaid")
@@ -1133,7 +1139,13 @@ function createCommandExecutor(options = {}) {
   async function handleSettingsCommand(args = []) {
     const section = String(args[0] || "").trim().toLowerCase();
     if (!section) {
-      logMessage("error", "{white-fg}✗{/white-fg} Usage: /settings ucode [show|set|clear ...]");
+      logMessage("error", "{white-fg}✗{/white-fg} Usage: /settings <router|ucode> ...");
+      return;
+    }
+
+    if (section === "router") {
+      const subArgs = args.slice(1);
+      await handleRouterSettingsCommand(subArgs);
       return;
     }
 
@@ -1147,7 +1159,88 @@ function createCommandExecutor(options = {}) {
       return;
     }
 
-    logMessage("error", "{white-fg}✗{/white-fg} Unknown settings section. Use: ucode");
+    logMessage("error", "{white-fg}✗{/white-fg} Unknown settings section. Use: router, ucode");
+  }
+
+  async function handleRouterSettingsCommand(args = []) {
+    const first = String(args[0] || "").trim().toLowerCase();
+    const hasInlineKv = args.some((item) => String(item || "").includes("="));
+    const action = !first ? "show" : (hasInlineKv ? "set" : first);
+
+    if (action === "show" || action === "status") {
+      const config = loadConfig(projectRoot) || {};
+      const mode = normalizeControllerMode(config.controllerMode);
+      logMessage("system", "{cyan-fg}router config:{/cyan-fg}");
+      logMessage("system", `  • controllerMode: ${mode}`);
+      logMessage("system", `  • provider: ${String(config.routerProvider || "").trim() || "(unset)"}`);
+      logMessage("system", `  • model: ${String(config.routerModel || "").trim() || "(unset)"}`);
+      logMessage("system", "  • allowed modes: main | loop | legacy | shadow");
+      return;
+    }
+
+    if (action === "set") {
+      const kvArgs = hasInlineKv ? args : args.slice(1);
+      const kv = parseKeyValueArgs(kvArgs);
+      const updates = {};
+
+      if (Object.prototype.hasOwnProperty.call(kv, "mode")) {
+        const nextMode = normalizeControllerMode(kv.mode);
+        if (!["main", "loop", "legacy", "shadow"].includes(nextMode) || nextMode !== String(kv.mode || "").trim().toLowerCase()) {
+          logMessage("error", "{white-fg}✗{/white-fg} Usage: /settings router set mode=<main|loop|legacy|shadow> provider=<id> model=<id>");
+          return;
+        }
+        updates.controllerMode = nextMode;
+      }
+      if (Object.prototype.hasOwnProperty.call(kv, "provider")) updates.routerProvider = String(kv.provider || "").trim();
+      if (Object.prototype.hasOwnProperty.call(kv, "model")) updates.routerModel = String(kv.model || "").trim();
+
+      if (Object.keys(updates).length === 0) {
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /settings router set mode=<main|loop|legacy|shadow> provider=<id> model=<id>");
+        return;
+      }
+
+      saveConfig(projectRoot, updates);
+      logMessage("system", "{white-fg}✓{/white-fg} router config updated");
+      if (Object.prototype.hasOwnProperty.call(updates, "controllerMode")) {
+        logMessage("system", `  • controllerMode: ${updates.controllerMode}`);
+      }
+      if (Object.prototype.hasOwnProperty.call(updates, "routerProvider")) {
+        logMessage("system", `  • provider: ${updates.routerProvider || "(unset)"}`);
+      }
+      if (Object.prototype.hasOwnProperty.call(updates, "routerModel")) {
+        logMessage("system", `  • model: ${updates.routerModel || "(unset)"}`);
+      }
+      await restartDaemon(projectRoot);
+      return;
+    }
+
+    if (action === "clear") {
+      const fieldsRaw = args.slice(1).map((item) => String(item || "").trim().toLowerCase()).filter(Boolean);
+      const fields = fieldsRaw.length === 0 ? ["all"] : fieldsRaw;
+      const updates = {};
+      const clearAll = fields.includes("all");
+      if (clearAll || fields.includes("mode")) updates.controllerMode = "main";
+      if (clearAll || fields.includes("provider")) updates.routerProvider = "";
+      if (clearAll || fields.includes("model")) updates.routerModel = "";
+      if (Object.keys(updates).length === 0) {
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /settings router clear [mode|provider|model|all]");
+        return;
+      }
+      saveConfig(projectRoot, updates);
+      logMessage("system", "{white-fg}✓{/white-fg} router config cleared");
+      await restartDaemon(projectRoot);
+      return;
+    }
+
+    const nextMode = normalizeControllerMode(action);
+    if (nextMode !== action || !["main", "loop", "legacy", "shadow"].includes(nextMode)) {
+      logMessage("error", "{white-fg}✗{/white-fg} Usage: /settings router <main|loop|legacy|shadow>");
+      return;
+    }
+
+    saveConfig(projectRoot, { controllerMode: nextMode });
+    logMessage("system", `{white-fg}✓{/white-fg} router mode set to ${nextMode}`);
+    await restartDaemon(projectRoot);
   }
 
   function parseUcodeConfigKv(args = []) {

package/src/chat/commands.js

@@ -38,10 +38,10 @@ const COMMAND_TREE = {
   "/group": {
     desc: "Agent group orchestration",
     children: {
-      run: { desc: "Launch a group template" },
+      run: { desc: "Launch a group template", order: 1 },
+      diagram: { desc: "Render group diagram (ascii|mermaid)", order: 2 },
       stop: { desc: "Stop a running group" },
       status: { desc: "Show group runtime status" },
-      diagram: { desc: "Render group diagram (ascii|mermaid)" },
       template: { desc: "Template ops (list/show/validate/new)" },
       templates: { desc: "List available templates" },
     },
@@ -87,7 +87,26 @@ const COMMAND_TREE = {
   "/settings": {
     desc: "Settings operations",
     children: {
-      ucode: { desc: "Manage ucode model provider config" },
+      router: {
+        desc: "Manage controller routing mode/provider/model",
+        children: {
+          show: { desc: "Show router mode/provider/model", order: 1 },
+          set: { desc: "Set router mode/provider/model", order: 2 },
+          clear: { desc: "Clear router provider/model or reset mode", order: 3 },
+          main: { desc: "Set router mode to main", order: 4 },
+          loop: { desc: "Set router mode to loop", order: 5 },
+          legacy: { desc: "Set router mode to legacy", order: 6 },
+          shadow: { desc: "Set router mode to shadow", order: 7 },
+        },
+      },
+      ucode: {
+        desc: "Manage ucode model provider config",
+        children: {
+          show: { desc: "Show ucode provider/model/url/key", order: 1 },
+          set: { desc: "Set ucode provider/model/url/key", order: 2 },
+          clear: { desc: "Clear ucode provider/model/url/key", order: 3 },
+        },
+      },
     },
   },
   "/skills": {
@@ -101,7 +120,7 @@ const COMMAND_TREE = {
   "/ufoo": { desc: "ufoo protocol (session marker)" },
 };
 
-const COMMAND_ORDER = ["/launch", "/bus", "/ctx"];
+const COMMAND_ORDER = ["/launch", "/group", "/bus", "/ctx"];
 const COMMAND_ORDER_MAP = new Map(COMMAND_ORDER.map((cmd, idx) => [cmd, idx]));
 
 function sortCommands(a, b) {
@@ -112,30 +131,34 @@ function sortCommands(a, b) {
 }
 
 function buildCommandRegistry(tree) {
+  function mapNode(node = {}) {
+    const entry = {
+      desc: node.desc || "",
+      order: Number.isFinite(node.order) ? node.order : undefined,
+    };
+    if (node.children) {
+      entry.subcommands = Object.keys(node.children)
+        .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,
+          ...mapNode(node.children[sub]),
+        }));
+    }
+    return entry;
+  }
+
   return Object.keys(tree)
     .sort(sortCommands)
     .map((cmd) => {
       const node = tree[cmd] || {};
-      const entry = { cmd, desc: node.desc || "" };
-      if (node.children) {
-        entry.subcommands = Object.keys(node.children)
-          .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;
+      return { cmd, ...mapNode(node) };
     });
 }
 

package/src/chat/completionController.js

@@ -11,6 +11,19 @@ function sortSubcommandEntries(a, b) {
   return String(a && a.cmd ? a.cmd : "").localeCompare(String(b && b.cmd ? b.cmd : ""), "en", { sensitivity: "base" });
 }
 
+function mapSubcommandSuggestions(subs = [], parentCmd, tokenIndex, filterText = "") {
+  const normalizedFilter = String(filterText || "").toLowerCase();
+  return subs
+    .filter((sub) => String(sub && sub.cmd ? sub.cmd : "").toLowerCase().startsWith(normalizedFilter))
+    .map((sub) => ({
+      ...sub,
+      isSubcommand: true,
+      parentCmd,
+      tokenIndex,
+    }))
+    .sort(sortSubcommandEntries);
+}
+
 function createCompletionController(options = {}) {
   const {
     input,
@@ -217,14 +230,14 @@ function createCompletionController(options = {}) {
           subs = Array.from(merged.values());
         }
         if (isLaunch) {
-          return subs
-            .map((sub) => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
-            .sort(sortSubcommandEntries);
+          return mapSubcommandSuggestions(subs, mainCmd, 1, "");
+        }
+        const selectedSub = subs.find((sub) => String(sub && sub.cmd ? sub.cmd : "").toLowerCase() === subFilter.toLowerCase());
+        if (selectedSub && selectedSub.subcommands && (parts.length > 2 || endsWithSpace)) {
+          const nestedFilter = parts[2] || "";
+          return mapSubcommandSuggestions(selectedSub.subcommands, mainCmd, 2, nestedFilter);
         }
-        return subs
-          .filter((sub) => sub.cmd.toLowerCase().startsWith(subFilter.toLowerCase()))
-          .map((sub) => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
-          .sort(sortSubcommandEntries);
+        return mapSubcommandSuggestions(subs, mainCmd, 1, subFilter);
       }
       return [];
     }
@@ -312,8 +325,10 @@ function createCompletionController(options = {}) {
 
     if (selected.isSubcommand) {
       const parts = trimmed.split(/\s+/);
-      const base = parts[0] || "";
-      const completedCore = base ? `${base} ${selected.cmd}` : selected.cmd;
+      const tokenIndex = Number.isInteger(selected.tokenIndex) ? selected.tokenIndex : 1;
+      while (parts.length <= tokenIndex) parts.push("");
+      parts[tokenIndex] = selected.cmd;
+      const completedCore = parts.slice(0, tokenIndex + 1).join(" ").trim();
       const isComplete = trimmed === completedCore || trimmed.startsWith(`${completedCore} `);
       return { text: `${completedCore} `, isComplete };
     }
@@ -353,8 +368,10 @@ function createCompletionController(options = {}) {
       input.value = `@${mentionTarget} `;
     } else if (selected.isSubcommand) {
       const parts = input.value.split(/\s+/);
-      parts[parts.length - 1] = selected.cmd;
-      input.value = `${parts.join(" ")} `;
+      const tokenIndex = Number.isInteger(selected.tokenIndex) ? selected.tokenIndex : 1;
+      while (parts.length <= tokenIndex) parts.push("");
+      parts[tokenIndex] = selected.cmd;
+      input.value = `${parts.slice(0, tokenIndex + 1).join(" ")} `;
     } else if (selected.isArgumentSuggestion) {
       const prefix = String(selected.argumentPrefix || "").trim();
       input.value = prefix ? `${prefix} ${selected.cmd} ` : `${selected.cmd} `;
@@ -369,7 +386,7 @@ function createCompletionController(options = {}) {
     }
     updateDraftFromInput();
 
-    if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
+    if (selected.subcommands && selected.subcommands.length > 0) {
       show(input.value);
     } else if (
       selected.isSubcommand
@@ -417,7 +434,7 @@ function createCompletionController(options = {}) {
         const nextPreview = preview(selected);
         if (!nextPreview.isComplete) {
           applyPreview(nextPreview);
-          if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
+          if (selected.subcommands && selected.subcommands.length > 0) {
             show(input.value);
           } else if (
             selected.isSubcommand

package/src/config.js

@@ -7,7 +7,7 @@ const UCODE_FIELDS = ["ucodeProvider", "ucodeModel", "ucodeBaseUrl", "ucodeApiKe
 const DEFAULT_CONFIG = {
   launchMode: "auto",
   agentProvider: "codex-cli",
-  controllerMode: "legacy",
+  controllerMode: "main",
   codexInternalThreadMode: "legacy",
   codexAuthPath: "",
   claudeOauthProfile: "",
@@ -42,7 +42,8 @@ function normalizeAgentProvider(value) {
 function normalizeControllerMode(value) {
   const raw = String(value || "").trim().toLowerCase();
   if (raw === "shadow") return "shadow";
-  if (raw === "router-api") return "router-api";
+  if (raw === "router-api") return "main";
+  if (raw === "main") return "main";
   if (raw === "loop") return "loop";
   return "legacy";
 }
@@ -95,7 +96,9 @@ function loadConfig(projectRoot) {
       ...raw,
       launchMode: normalizeLaunchMode(raw.launchMode),
       agentProvider: normalizeAgentProvider(raw.agentProvider),
-      controllerMode: normalizeControllerMode(raw.controllerMode),
+      controllerMode: Object.prototype.hasOwnProperty.call(raw, "controllerMode")
+        ? normalizeControllerMode(raw.controllerMode)
+        : DEFAULT_CONFIG.controllerMode,
       codexInternalThreadMode: normalizeCodexInternalThreadMode(raw.codexInternalThreadMode),
       codexAuthPath: normalizeCodexAuthPath(raw.codexAuthPath),
       claudeOauthProfile: normalizeClaudeOauthProfile(raw.claudeOauthProfile),

package/src/controller/flags.js

@@ -5,7 +5,7 @@ const { loadConfig, normalizeControllerMode } = require("../config");
 const CONTROLLER_MODES = Object.freeze({
   LEGACY: "legacy",
   SHADOW: "shadow",
-  ROUTER_API: "router-api",
+  MAIN: "main",
   LOOP: "loop",
 });
 
@@ -15,7 +15,11 @@ const appliedControllerModes = new Map();
 const appliedControllerModeHistory = new Map();
 
 function readProcessControllerMode(env = process.env) {
-  return normalizeControllerMode(env.UFOO_CONTROLLER_MODE);
+  const normalized = normalizeControllerMode(env.UFOO_CONTROLLER_MODE);
+  if (normalized !== CONTROLLER_MODES.LEGACY || String(env.UFOO_CONTROLLER_MODE || "").trim().toLowerCase() === CONTROLLER_MODES.LEGACY) {
+    return normalized;
+  }
+  return CONTROLLER_MODES.MAIN;
 }
 
 function resolveControllerMode({
@@ -37,7 +41,10 @@ function resolveControllerMode({
     : null;
   if (loadedConfig) {
     const projectMode = normalizeControllerMode(loadedConfig.controllerMode);
-    return projectMode;
+    if (projectMode !== CONTROLLER_MODES.LEGACY || String(loadedConfig.controllerMode || "").trim().toLowerCase() === CONTROLLER_MODES.LEGACY) {
+      return projectMode;
+    }
+    return CONTROLLER_MODES.MAIN;
   }
 
   return readProcessControllerMode(env);
@@ -62,7 +69,7 @@ function pushModeHistory(key, previousMode, normalizedMode, messageId) {
 
 function applyControllerModeForMessage({
   projectRoot,
-  nextMode = CONTROLLER_MODES.LEGACY,
+  nextMode = CONTROLLER_MODES.MAIN,
   messageId = "",
 } = {}) {
   const key = getControllerModeStateKey(projectRoot);
@@ -96,7 +103,7 @@ function rollbackControllerModeForMessage({
   const key = getControllerModeStateKey(projectRoot);
   const list = appliedControllerModeHistory.get(key) || [];
   const lastTransition = list.length > 0 ? list[list.length - 1] : null;
-  const currentMode = appliedControllerModes.get(key) || CONTROLLER_MODES.LEGACY;
+  const currentMode = appliedControllerModes.get(key) || CONTROLLER_MODES.MAIN;
 
   if (!lastTransition) {
     return {
@@ -135,7 +142,7 @@ function rollbackControllerModeForMessage({
 
 function getAppliedControllerMode(projectRoot) {
   const key = getControllerModeStateKey(projectRoot);
-  return appliedControllerModes.get(key) || CONTROLLER_MODES.LEGACY;
+  return appliedControllerModes.get(key) || CONTROLLER_MODES.MAIN;
 }
 
 function getControllerModeHistoryForTests(projectRoot) {

package/src/controller/gateRouter.js

@@ -2,7 +2,7 @@
 
 const { loadConfig } = require("../config");
 
-const DEFAULT_EXECUTION_PATH = "legacy";
+const DEFAULT_EXECUTION_PATH = "main";
 const DEFAULT_CONFIDENCE_THRESHOLD = 0.6;
 const DEFAULT_TIMEOUT_MS = 5000;
 
@@ -55,7 +55,8 @@ const NON_ROUTING_PATTERNS = [
 
 function normalizeExecutionPath(value = "") {
   const text = String(value || "").trim().toLowerCase();
-  if (text === "router-api") return "router-api";
+  if (text === "router-api") return "main";
+  if (text === "main") return "main";
   if (text === "shadow") return "shadow";
   if (text === "loop") return "loop";
   return DEFAULT_EXECUTION_PATH;
@@ -110,7 +111,7 @@ function shouldUseGateRouter({
   return {
     executionPath,
     intent,
-    enabled: executionPath === "router-api" || executionPath === "loop",
+    enabled: executionPath === "main" || executionPath === "loop",
   };
 }
 

package/src/daemon/index.js

@@ -1770,19 +1770,34 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         );
         return;
       }
-      const target = req.group_id || req.groupId || req.instance || req.alias || req.target || "";
-      if (!target) {
-        socket.write(
-          `${JSON.stringify({
-            type: IPC_RESPONSE_TYPES.ERROR,
-            error: "group diagram requires alias|group_id",
-          })}
-`,
-        );
-        return;
-      }
+      let target = req.group_id || req.groupId || req.instance || req.alias || req.target || "";
       const format = normalizeFormat(req.format || (req.mermaid ? "mermaid" : "ascii"));
       try {
+        if (!target || target === "current") {
+          const latest = daemonGroupOrchestrator.getStatus({});
+          if (latest && latest.ok && Array.isArray(latest.groups) && latest.groups.length > 0) {
+            target = latest.groups[0].group_id || "";
+          }
+        }
+        if (!target) {
+          socket.write(
+            `${JSON.stringify({
+              type: IPC_RESPONSE_TYPES.RESPONSE,
+              data: {
+                reply: "Group diagram failed: no running groups and no template alias provided",
+                group: {
+                  ok: false,
+                  mode: "runtime",
+                  target: "",
+                  format,
+                  error: "no running groups",
+                },
+              },
+            })}
+`,
+          );
+          return;
+        }
         const runtimeState = daemonGroupOrchestrator.getStatus({ group_id: target });
         if (runtimeState && runtimeState.ok === false && runtimeState.error === "invalid group_id") {
           socket.write(