u-foo 1.7.4 → 1.8.0

package/src/chat/commandExecutor.js

@@ -6,6 +6,8 @@ const { runGroupCoreCommand } = require("../cli/groupCoreCommands");
 const { loadConfig: loadProjectConfig, saveConfig: saveProjectConfig, loadGlobalUcodeConfig, saveGlobalUcodeConfig } = require("../config");
 const { resolveTransport } = require("../code/nativeRunner");
 const { parseIntervalMs, formatIntervalMs } = require("./cronScheduler");
+const { isGlobalControllerProjectRoot, resolveGlobalControllerUfooDir } = require("../globalMode");
+const { loadPromptProfileRegistry } = require("../group/promptProfiles");
 
 function defaultCreateDoctor(projectRoot) {
   const UfooDoctor = require("../doctor");
@@ -92,6 +94,7 @@ function createCommandExecutor(options = {}) {
     stopCronTask = () => false,
     runGroupCore = runGroupCoreCommand,
     requestCron = null,
+    globalMode = false,
     listProjects = () => [],
     getCurrentProject = () => ({ projectRoot }),
     switchProject = async () => ({ ok: false, error: "project switching unavailable" }),
@@ -404,7 +407,7 @@ function createCommandExecutor(options = {}) {
     if (args.length === 0) {
       logMessage(
         "error",
-        "{white-fg}✗{/white-fg} Usage: /launch <claude|codex|ucode> [nickname=<name>] [count=<n>] [scope=inplace|window]"
+        "{white-fg}✗{/white-fg} Usage: /launch <claude|codex|ucode> [nickname=<name>] [profile=<id>] [count=<n>] [scope=inplace|window]"
       );
       return;
     }
@@ -452,6 +455,7 @@ function createCommandExecutor(options = {}) {
     }
 
     const nickname = parsedOptions.nickname || "";
+    const promptProfile = parsedOptions.profile || parsedOptions.prompt_profile || "";
     const count = parseInt(parsedOptions.count || "1", 10);
     const scopeRaw = parsedOptions.scope || parsedOptions.launch_scope || parsedOptions.window || "";
     let launchScope = normalizeLaunchScopeOption(scopeRaw, "inplace");
@@ -473,6 +477,10 @@ function createCommandExecutor(options = {}) {
       logMessage("error", "{white-fg}✗{/white-fg} nickname requires count=1");
       return;
     }
+    if (promptProfile && count > 1) {
+      logMessage("error", "{white-fg}✗{/white-fg} profile requires count=1");
+      return;
+    }
 
     try {
       const request = {
@@ -480,6 +488,7 @@ function createCommandExecutor(options = {}) {
         agent: normalizedAgent,
         count: Number.isFinite(count) ? count : 1,
         nickname,
+        prompt_profile: promptProfile,
         launch_scope: launchScope,
         ...collectHostLaunchRequestContext(),
       };
@@ -494,6 +503,52 @@ function createCommandExecutor(options = {}) {
     }
   }
 
+  async function handleRoleCommand(args = []) {
+    const action = String(args[0] || "").trim().toLowerCase();
+    if (action === "list" || action === "ls") {
+      try {
+        const registry = loadPromptProfileRegistry(projectRoot);
+        const profiles = registry.profiles || [];
+        if (profiles.length === 0) {
+          logMessage("system", "{white-fg}⚙{/white-fg} No prompt profiles found.");
+          return;
+        }
+        logMessage("system", `{white-fg}⚙{/white-fg} Available prompt profiles (${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 profiles: ${escapeBlessed(err.message)}`);
+      }
+      return;
+    }
+
+    const target = String(args[0] || "").trim();
+    const profile = String(args[1] || "").trim();
+    if (!target || !profile) {
+      logMessage("error", "{white-fg}✗{/white-fg} Usage: /role <agent-id|nickname> <prompt-profile>");
+      logMessage("error", "       /role list");
+      return;
+    }
+
+    try {
+      send({
+        type: IPC_REQUEST_TYPES.ASSIGN_ROLE,
+        target,
+        prompt_profile: profile,
+      });
+      schedule(requestStatus, 1000);
+    } catch (err) {
+      logMessage("error", `{white-fg}✗{/white-fg} Role assignment failed: ${escapeBlessed(err.message)}`);
+    }
+  }
+
   async function handleResumeCommand(args = []) {
     const action = String(args[0] || "").toLowerCase();
     if (action === "list" || action === "ls") {
@@ -517,7 +572,11 @@ function createCommandExecutor(options = {}) {
 
     if (subcommand === "list") {
       const rowsRaw = await Promise.resolve(listProjects());
-      const rows = Array.isArray(rowsRaw) ? rowsRaw : [];
+      const rows = (Array.isArray(rowsRaw) ? rowsRaw : []).filter((row) => {
+        if (!globalMode) return true;
+        const root = row && row.project_root ? String(row.project_root) : "";
+        return !isGlobalControllerProjectRoot(root);
+      });
       const current = await Promise.resolve(getCurrentProject());
       const currentRoot = current && current.project_root ? String(current.project_root) : "";
       if (rows.length === 0) {
@@ -545,12 +604,19 @@ function createCommandExecutor(options = {}) {
         logMessage("error", "{white-fg}✗{/white-fg} Current project unavailable");
         return;
       }
+      if (globalMode && isGlobalControllerProjectRoot(current.project_root)) {
+        logMessage(
+          "system",
+          `{cyan-fg}Current:{/cyan-fg} global controller (${escapeBlessed(resolveGlobalControllerUfooDir())})`
+        );
+        return;
+      }
       logMessage("system", `{cyan-fg}Current:{/cyan-fg} ${escapeBlessed(current.project_root)}`);
       return;
     }
 
     if (subcommand === "switch") {
-      const target = String(args[1] || "").trim();
+      const target = args.slice(1).join(" ").trim();
       if (!target) {
         logMessage("error", "{white-fg}✗{/white-fg} Usage: /project switch <index|path>");
         return;
@@ -570,6 +636,27 @@ function createCommandExecutor(options = {}) {
     logMessage("error", "{white-fg}✗{/white-fg} Unknown project command. Use: list, current, switch");
   }
 
+  async function handleOpenCommand(args = []) {
+    if (!globalMode) {
+      logMessage("error", "{white-fg}✗{/white-fg} /open is only available in global mode");
+      return;
+    }
+    const target = args.join(" ").trim();
+    if (!target) {
+      logMessage("error", "{white-fg}✗{/white-fg} Usage: /open <path>");
+      return;
+    }
+    logMessage("system", `{white-fg}⚙{/white-fg} Opening project: ${escapeBlessed(target)}`);
+    const result = await Promise.resolve(switchProject({ target }));
+    if (!result || result.ok !== true) {
+      const reason = result && result.error ? String(result.error) : "open failed";
+      logMessage("error", `{white-fg}✗{/white-fg} Open failed: ${escapeBlessed(reason)}`);
+      return;
+    }
+    const nextRoot = result.project_root || result.projectRoot || "";
+    logMessage("system", `{white-fg}✓{/white-fg} Opened project: ${escapeBlessed(nextRoot)}`);
+  }
+
   function parseKeyValueArgs(args = []) {
     const parsed = {};
     for (const raw of args) {
@@ -688,6 +775,9 @@ function createCommandExecutor(options = {}) {
     const targetsRaw = String(
       kv.target || kv.targets || kv.agent || kv.agents || ""
     ).trim();
+    const title = String(
+      kv.title || kv.name || kv.label || ""
+    ).trim();
     const prompt = String(
       kv.prompt || kv.message || kv.msg || nonKvParts.join(" ") || ""
     ).trim();
@@ -695,7 +785,7 @@ function createCommandExecutor(options = {}) {
     if ((!intervalRaw && !atRaw) || !targetsRaw || !prompt) {
       logMessage(
         "error",
-        "{white-fg}✗{/white-fg} Usage: /cron start every=<10s|5m> or at=\"YYYY-MM-DD HH:mm\" target=<agent1,agent2> prompt=\"...\""
+        "{white-fg}✗{/white-fg} Usage: /cron start every=<10s|5m> or at=\"YYYY-MM-DD HH:mm\" target=<agent1,agent2> [title=\"...\"] prompt=\"...\""
       );
       return;
     }
@@ -728,21 +818,18 @@ function createCommandExecutor(options = {}) {
     }
 
     if (typeof requestCron === "function") {
+      const request = {
+        operation: "start",
+        targets,
+        prompt,
+      };
+      if (title) request.title = title;
       if (atMs > 0) {
-        requestCron({
-          operation: "start",
-          once_at_ms: atMs,
-          targets,
-          prompt,
-        });
+        request.once_at_ms = atMs;
       } else {
-        requestCron({
-          operation: "start",
-          interval_ms: intervalMs,
-          targets,
-          prompt,
-        });
+        request.interval_ms = intervalMs;
       }
+      requestCron(request);
       schedule(requestStatus, 200);
       return;
     }
@@ -752,11 +839,13 @@ function createCommandExecutor(options = {}) {
       return;
     }
 
-    const task = createCronTask({
+    const taskPayload = {
       intervalMs,
       targets,
       prompt,
-    });
+    };
+    if (title) taskPayload.title = title;
+    const task = createCronTask(taskPayload);
     if (!task) {
       logMessage("error", "{white-fg}✗{/white-fg} Failed to create cron task");
       return;
@@ -764,7 +853,7 @@ function createCommandExecutor(options = {}) {
 
     logMessage(
       "system",
-      `{white-fg}✓{/white-fg} Cron started ${task.id}: ${atMs > 0 ? `at ${formatCronAt(atMs)}` : `every ${formatIntervalMs(intervalMs)}`} -> ${targets.join(", ")}`
+      `{white-fg}✓{/white-fg} Cron started ${task.id}: ${task.label || `${atMs > 0 ? `at ${formatCronAt(atMs)}` : `every ${formatIntervalMs(intervalMs)}`} -> ${targets.join(", ")}`}`
     );
   }
 
@@ -1118,12 +1207,18 @@ function createCommandExecutor(options = {}) {
       case "launch":
         await handleLaunchCommand(args);
         return true;
+      case "open":
+        await handleOpenCommand(args);
+        return true;
       case "resume":
         await handleResumeCommand(args);
         return true;
       case "project":
         await handleProjectCommand(args);
         return true;
+      case "role":
+        await handleRoleCommand(args);
+        return true;
       case "cron":
         await handleCronCommand(args);
         return true;
@@ -1152,8 +1247,10 @@ function createCommandExecutor(options = {}) {
     handleCtxCommand,
     handleSkillsCommand,
     handleLaunchCommand,
+    handleOpenCommand,
     handleResumeCommand,
     handleProjectCommand,
+    handleRoleCommand,
     handleCronCommand,
     handleGroupCommand,
     handleSettingsCommand,

package/src/chat/commands.js

@@ -30,7 +30,7 @@ const COMMAND_TREE = {
   "/cron": {
     desc: "Cron scheduler operations",
     children: {
-      start: { desc: "Create cron task" },
+      start: { desc: "Create cron task (optional title)" },
       list: { desc: "List cron tasks" },
       stop: { desc: "Stop cron task by id or all" },
     },
@@ -47,6 +47,7 @@ const COMMAND_TREE = {
     },
   },
   "/init": { desc: "Initialize modules" },
+  "/open": { desc: "Open project path in global mode" },
   "/launch": {
     desc: "Launch new agent",
     children: {
@@ -63,6 +64,12 @@ const COMMAND_TREE = {
       switch: { desc: "Switch daemon connection to project index/path" },
     },
   },
+  "/role": {
+    desc: "Assign preset role to an existing agent",
+    children: {
+      list: { desc: "List available prompt profiles" },
+    },
+  },
   "/resume": {
     desc: "Resume agents (optional nickname) or list recoverable targets",
     children: {

package/src/chat/completionController.js

@@ -11,6 +11,7 @@ function createCompletionController(options = {}) {
     completionPanel,
     promptBox,
     commandRegistry = [],
+    getGroupTemplateCandidates = () => [],
     getMentionCandidates = () => [],
     normalizeCommandPrefix = () => {},
     truncateText = (text) => String(text || ""),
@@ -141,8 +142,33 @@ function createCompletionController(options = {}) {
     const parts = trimmed.split(/\s+/);
     const mainCmd = parts[0];
     const isLaunch = mainCmd && mainCmd.toLowerCase() === "/launch";
+    const isGroup = mainCmd && mainCmd.toLowerCase() === "/group";
     const wantsSubcommands = (parts.length > 1 || (endsWithSpace && parts.length === 1));
 
+    if (isGroup) {
+      const groupSubcommand = String(parts[1] || "").trim().toLowerCase();
+      const wantsGroupRunArgs = groupSubcommand === "run" && (parts.length > 2 || endsWithSpace);
+      if (wantsGroupRunArgs) {
+        const aliasFilter = String(parts[2] || "").trim().toLowerCase();
+        return (Array.isArray(getGroupTemplateCandidates()) ? getGroupTemplateCandidates() : [])
+          .map((item) => {
+            const alias = String(item && item.alias ? item.alias : item && item.cmd ? item.cmd : "").trim();
+            if (!alias) return null;
+            const desc = String(item && item.desc ? item.desc : item && item.name ? item.name : "").trim();
+            const source = String(item && item.source ? item.source : "").trim();
+            const detail = [desc, source].filter(Boolean).join(" · ");
+            return {
+              cmd: alias,
+              desc: detail,
+              isArgumentSuggestion: true,
+              argumentPrefix: "/group run",
+            };
+          })
+          .filter((item) => item && (!aliasFilter || item.cmd.toLowerCase().startsWith(aliasFilter)))
+          .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) =>
@@ -261,6 +287,13 @@ function createCompletionController(options = {}) {
       return { text: `${completedCore} `, isComplete };
     }
 
+    if (selected.isArgumentSuggestion) {
+      const prefix = String(selected.argumentPrefix || "").trim();
+      const completedCore = prefix ? `${prefix} ${selected.cmd}` : selected.cmd;
+      const isComplete = trimmed === completedCore || trimmed.startsWith(`${completedCore} `);
+      return { text: `${completedCore} `, isComplete };
+    }
+
     const completedCore = selected.cmd;
     const hasChildren = selected.subcommands && selected.subcommands.length > 0;
     const isComplete =
@@ -291,6 +324,9 @@ function createCompletionController(options = {}) {
       const parts = input.value.split(/\s+/);
       parts[parts.length - 1] = selected.cmd;
       input.value = `${parts.join(" ")} `;
+    } else if (selected.isArgumentSuggestion) {
+      const prefix = String(selected.argumentPrefix || "").trim();
+      input.value = prefix ? `${prefix} ${selected.cmd} ` : `${selected.cmd} `;
     } else {
       input.value = `${selected.cmd} `;
     }
@@ -304,6 +340,8 @@ 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") {
+      show(input.value);
     } else {
       hide();
     }
@@ -346,6 +384,8 @@ 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") {
+            show(input.value);
           } else {
             hide();
           }

package/src/chat/cronScheduler.js

@@ -29,13 +29,39 @@ function sanitizeSummaryText(value = "") {
     .trim();
 }
 
+function truncateCronText(value = "", maxLength = 24) {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(1, maxLength - 3))}...`;
+}
+
+function resolveTaskTitle(task = {}) {
+  const explicitTitle = truncateCronText(
+    sanitizeSummaryText(task.title || "").replace(/:/g, "-"),
+    24
+  );
+  if (explicitTitle) return explicitTitle;
+  const fallbackTitle = truncateCronText(
+    sanitizeSummaryText(task.prompt || "").replace(/:/g, "-"),
+    24
+  );
+  return fallbackTitle || "(empty)";
+}
+
+function buildTaskLabel(task = {}) {
+  const targets = Array.isArray(task.targets) && task.targets.length > 0
+    ? task.targets.join("+")
+    : "unknown";
+  const title = resolveTaskTitle(task);
+  const interval = formatIntervalMs(task.intervalMs || 0);
+  return `${targets}:${title}:${interval}`;
+}
+
 function summarizeTask(task = {}) {
   const id = String(task.id || "");
-  const interval = formatIntervalMs(task.intervalMs || 0);
-  const targets = Array.isArray(task.targets) ? task.targets.join("+") : "";
-  const promptRaw = sanitizeSummaryText(task.prompt || "");
-  const prompt = promptRaw.length > 24 ? `${promptRaw.slice(0, 24)}...` : promptRaw;
-  return `${id}@${interval}->${targets}: ${prompt || "(empty)"}`;
+  const label = buildTaskLabel(task);
+  return id ? `${id} ${label}` : label;
 }
 
 function createCronScheduler(options = {}) {
@@ -58,7 +84,7 @@ function createCronScheduler(options = {}) {
     }
   }
 
-  function addTask({ intervalMs = 0, targets = [], prompt = "" } = {}) {
+  function addTask({ intervalMs = 0, targets = [], prompt = "", title = "" } = {}) {
     const safeInterval = Number.parseInt(intervalMs, 10);
     const safeTargets = Array.isArray(targets)
       ? targets.map((item) => String(item || "").trim()).filter(Boolean)
@@ -74,6 +100,7 @@ function createCronScheduler(options = {}) {
       intervalMs: safeInterval,
       targets: Array.from(new Set(safeTargets)),
       prompt: safePrompt,
+      title: resolveTaskTitle({ title, prompt: safePrompt }),
       createdAt: nowFn(),
       lastRunAt: 0,
       tickCount: 0,
@@ -100,6 +127,7 @@ function createCronScheduler(options = {}) {
     notifyChange();
     return {
       ...task,
+      label: buildTaskLabel(task),
       summary: summarizeTask(task),
     };
   }
@@ -110,9 +138,11 @@ function createCronScheduler(options = {}) {
       intervalMs: task.intervalMs,
       targets: task.targets.slice(),
       prompt: task.prompt,
+      title: task.title,
       createdAt: task.createdAt,
       lastRunAt: task.lastRunAt,
       tickCount: task.tickCount,
+      label: buildTaskLabel(task),
       summary: summarizeTask(task),
     }));
   }
@@ -155,6 +185,7 @@ function createCronScheduler(options = {}) {
 module.exports = {
   parseIntervalMs,
   formatIntervalMs,
+  buildTaskLabel,
   summarizeTask,
   createCronScheduler,
 };

package/src/chat/daemonMessageRouter.js

@@ -254,12 +254,12 @@ function createDaemonMessageRouter(options = {}) {
         if (task.mode === "once") {
           logMessage(
             "system",
-            `{white-fg}✓{/white-fg} Cron scheduled ${escapeBlessed(task.id)} at ${escapeBlessed(task.onceAt || String(task.onceAtMs || ""))}`
+            `{white-fg}✓{/white-fg} Cron scheduled ${escapeBlessed(task.id)}: ${escapeBlessed(task.label || task.onceAt || String(task.onceAtMs || ""))}`
           );
         } else {
           logMessage(
             "system",
-            `{white-fg}✓{/white-fg} Cron started ${escapeBlessed(task.id)}: every ${escapeBlessed(task.interval || String(task.intervalMs || ""))}`
+            `{white-fg}✓{/white-fg} Cron started ${escapeBlessed(task.id)}: ${escapeBlessed(task.label || task.interval || String(task.intervalMs || ""))}`
           );
         }
       } else if (operation === "stop") {
@@ -286,7 +286,14 @@ function createDaemonMessageRouter(options = {}) {
       payload.disambiguate.candidates.length > 0
     ) {
       const pending = getPending();
-      setPending({ disambiguate: payload.disambiguate, original: pending && pending.original });
+      const routedProjectRoot = payload.routed_project && payload.routed_project.project_root
+        ? payload.routed_project.project_root
+        : (pending && pending.project_root ? pending.project_root : "");
+      setPending({
+        disambiguate: payload.disambiguate,
+        original: pending && pending.original,
+        project_root: routedProjectRoot || undefined,
+      });
       const prompt = payload.disambiguate.prompt || "Choose target:";
       resolveStatusLine(`{gray-fg}?{/gray-fg} ${escapeBlessed(prompt)}`);
       logMessage("disambiguate", `{white-fg}?{/white-fg} ${escapeBlessed(prompt)}`);
@@ -323,6 +330,19 @@ function createDaemonMessageRouter(options = {}) {
       requestStatus();
       return true;
     }
+    if (data.event === "controller_report") {
+      const report = data.report && typeof data.report === "object" ? data.report : {};
+      const publisher = report.agent_id || data.publisher || "ufoo-agent";
+      const displayName = resolveAgentDisplayName(publisher);
+      const detail = report.summary || report.message || data.message || report.task_id || "report";
+      logMessage(
+        "system",
+        `{gray-fg}↥{/gray-fg} {cyan-fg}${escapeBlessed(displayName)}{/cyan-fg} {gray-fg}→ ufoo-agent{/gray-fg} ${escapeBlessed(detail)}`
+      );
+      requestStatus();
+      renderScreen();
+      return true;
+    }
     const prefix = data.event === "broadcast" ? "{gray-fg}⇢{/gray-fg}" : "{gray-fg}↔{/gray-fg}";
     const publisher = data.publisher && data.publisher !== "unknown"
       ? data.publisher