u-foo 1.2.13 → 1.2.16

package/bin/ufoo.js

@@ -42,6 +42,155 @@ async function main() {
     await runChat(process.cwd());
     return;
   }
+
+  // Handle resume command to resume/launch agent sessions
+  if (cmd === "resume") {
+    const target = process.argv[3];
+    if (!target) {
+      console.error("Error: resume requires an agent type or nickname");
+      console.error("Usage: ufoo resume <ucode|uclaude|ucodex|nickname>");
+      console.error("");
+      console.error("Examples:");
+      console.error("  ufoo resume ucode      # Start new ucode agent");
+      console.error("  ufoo resume ucode-1    # Resume agent with nickname ucode-1");
+      console.error("  ufoo resume uclaude    # Start new uclaude agent");
+      process.exitCode = 1;
+      return;
+    }
+
+    const { execSync } = require("child_process");
+    const path = require("path");
+    const { spawn } = require("child_process");
+
+    // First check if it's a nickname for an existing online agent
+    let targetAgent = null;
+    try {
+      const statusOutput = execSync("ufoo bus status", { encoding: "utf8", cwd: process.cwd() });
+
+      // Parse online agents
+      const onlineAgents = [];
+      const lines = statusOutput.split("\n");
+      let inOnlineSection = false;
+
+      for (const line of lines) {
+        if (line.includes("Online agents:")) {
+          inOnlineSection = true;
+          continue;
+        }
+        if (inOnlineSection) {
+          const trimmedLine = line.trim();
+          if (!trimmedLine) continue;
+          if (trimmedLine.includes("Event statistics:") || trimmedLine.includes("===")) {
+            inOnlineSection = false;
+            continue;
+          }
+          // Parse agent line: "ufoo-code:abc123 (nickname)"
+          const agentMatch = trimmedLine.match(/^[-\s]*([a-z-]+:[a-f0-9]+|[a-z-]+)(?:\s+\(([^)]+)\))?/i);
+          if (agentMatch) {
+            const subscriberId = agentMatch[1];
+            const nickname = agentMatch[2] || "";
+            onlineAgents.push({ subscriberId, nickname });
+          }
+        }
+      }
+
+      // Check if target matches any online agent's nickname
+      for (const agent of onlineAgents) {
+        if (agent.nickname && agent.nickname === target) {
+          targetAgent = agent;
+          break;
+        }
+      }
+    } catch (err) {
+      // Ignore errors from bus status check
+    }
+
+    if (targetAgent) {
+      // Found an online agent with this nickname
+      // Determine the agent type from subscriber ID
+      const subscriberId = targetAgent.subscriberId;
+      const [agentType, sessionId] = subscriberId.split(":");
+
+      let scriptName = "";
+      let displayName = "";
+
+      if (agentType === "ufoo-code") {
+        scriptName = "ucode.js";
+        displayName = "ucode";
+      } else if (agentType === "claude-code") {
+        scriptName = "uclaude.js";
+        displayName = "uclaude";
+      } else if (agentType === "codex") {
+        scriptName = "ucodex.js";
+        displayName = "ucodex";
+      } else {
+        console.error(`Error: Unable to determine agent type for ${subscriberId}`);
+        process.exitCode = 1;
+        return;
+      }
+
+      console.log(`Resuming ${displayName} session for ${targetAgent.nickname} (${subscriberId})`);
+
+      // Set environment variable to indicate this is a resume
+      const scriptPath = path.join(__dirname, scriptName);
+      const env = { ...process.env };
+
+      // Pass the subscriber ID so the agent can reuse the same identity
+      env.UFOO_SUBSCRIBER_ID = subscriberId;
+
+      // Spawn the agent process - it will reuse the subscriber ID
+      const child = spawn(process.execPath, [scriptPath], {
+        stdio: "inherit",
+        cwd: process.cwd(),
+        env,
+      });
+
+      child.on("exit", (code) => {
+        process.exit(code || 0);
+      });
+
+      return;
+    }
+
+    // Not an existing online agent - check if it's an agent type to launch
+    const targetLower = target.toLowerCase();
+    let scriptName = "";
+
+    if (targetLower === "ucode" || targetLower === "ufoo-code" || targetLower === "ufoo") {
+      scriptName = "ucode.js";
+    } else if (targetLower === "uclaude" || targetLower === "claude-code" || targetLower === "claude") {
+      scriptName = "uclaude.js";
+    } else if (targetLower === "ucodex" || targetLower === "codex" || targetLower === "openai") {
+      scriptName = "ucodex.js";
+    } else {
+      // Not a valid agent type - might be an offline agent nickname
+      console.error(`Error: Agent '${target}' is not online and is not a valid agent type`);
+      console.error("");
+      console.error("Valid agent types: ucode, uclaude, ucodex");
+      console.error("");
+      console.error("To see online agents, run: ufoo bus status");
+      process.exitCode = 1;
+      return;
+    }
+
+    // Run the agent script directly for a new session
+    const scriptPath = path.join(__dirname, scriptName);
+    console.log(`Starting new ${target} session...`);
+
+    // Spawn the agent process and inherit stdio for interactive mode
+    const child = spawn(process.execPath, [scriptPath], {
+      stdio: "inherit",
+      cwd: process.cwd(),
+      env: process.env,
+    });
+
+    child.on("exit", (code) => {
+      process.exit(code || 0);
+    });
+
+    return;
+  }
+
   await runCli(process.argv);
 }
 

package/modules/online/SKILLS/ufoo-online/SKILL.md

@@ -62,7 +62,7 @@ Inbox retention: channel messages 7 days, room messages 30 days.
 ## Full Connect Options
 
 ```bash
-ufoo online connect --nickname <name> [--url <ws://...>] [--subscriber <id>]
+ufoo online connect --nickname <name> [--url <wss://...>] [--subscriber <id>]
   [--token <tok>] [--token-hash <hash>] [--world <name>] [--ping-ms <ms>]
   [--join <channel>] [--room <room-id> --room-password <pwd>]
   [--interval <ms>] [--allow-insecure-ws]
@@ -131,7 +131,7 @@ ufoo online inbox agent-b                               # See agent-a's message
 ### 2. Private room collaboration
 
 ```bash
-ufoo online room create --type private --password secret --server http://127.0.0.1:8787
+ufoo online room create --type private --password secret --server https://online.ufoo.dev
 # → returns room_id
 
 ufoo online connect --nickname dev-1 --room room_001 --room-password secret

package/package.json

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

package/scripts/postinstall.js

@@ -74,31 +74,49 @@ function forceSymlink(target, linkPath) {
       fs.rmSync(linkPath, { recursive: true, force: true });
     }
   } catch {
-    // doesn't exist — fine
+    // doesn't exist - fine
   }
   fs.symlinkSync(target, linkPath);
 }
 
-// Install ufoo skills as Claude Code slash commands (~/.claude/commands/<name>.md)
-// and as skill directories (~/.claude/skills/<name>/)
+function installClaudeCommands(home, sources) {
+  const commandsDir = path.join(home, ".claude", "commands");
+  fs.mkdirSync(commandsDir, { recursive: true });
+
+  for (const { name, md } of sources) {
+    forceSymlink(md, path.join(commandsDir, `${name}.md`));
+  }
+
+  console.log(`[postinstall] Installed ${sources.length} ufoo command(s) to ${commandsDir}`);
+}
+
+function installSkillDirs(targetDir, sources, label) {
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  for (const { name, dir } of sources) {
+    forceSymlink(dir, path.join(targetDir, name));
+  }
+
+  console.log(`[postinstall] Installed ${sources.length} ufoo skill(s) to ${label}`);
+}
+
+// Install ufoo skills for Claude and Codex at npm install time.
+// - Claude slash commands: ~/.claude/commands/<name>.md -> SKILL.md
+// - Claude skills: ~/.claude/skills/<name> -> skill dir
+// - Codex skills: ${CODEX_HOME:-~/.codex}/skills/<name> -> skill dir
 try {
   const pkgRoot = path.resolve(__dirname, "..");
   const home = os.homedir();
   const sources = collectSkillSources(pkgRoot);
 
   if (sources.length > 0) {
-    // Slash commands: ~/.claude/commands/<name>.md -> SKILL.md
-    const commandsDir = path.join(home, ".claude", "commands");
-    fs.mkdirSync(commandsDir, { recursive: true });
-
-    let installed = 0;
-    for (const { name, md } of sources) {
-      forceSymlink(md, path.join(commandsDir, `${name}.md`));
-      installed += 1;
-    }
-    console.log(`[postinstall] Installed ${installed} ufoo command(s) to ${commandsDir}`);
+    installClaudeCommands(home, sources);
+    installSkillDirs(path.join(home, ".claude", "skills"), sources, "~/.claude/skills");
+
+    const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+    installSkillDirs(path.join(codexHome, "skills"), sources, `${codexHome}/skills`);
   }
 } catch (err) {
-  // Non-fatal — skills can be installed manually via `ufoo skills install`
+  // Non-fatal - skills can be installed manually via `ufoo skills install`
   console.log(`[postinstall] Skipped skills install: ${err.message}`);
 }

package/src/agent/notifier.js

@@ -175,7 +175,11 @@ class AgentNotifier {
       data.message = `delivery failed to ${this.lastNickname || this.subscriber}: ${errorMessage || "unknown error"}`;
     }
     try {
-      await this.eventBus.send(publisher, "", this.subscriber, { event: "delivery", data });
+      await this.eventBus.send(publisher, "", this.subscriber, {
+        event: "delivery",
+        data,
+        silent: true,
+      });
     } catch {
       // ignore delivery emit failures
     }

package/src/agent/ufooAgent.js

@@ -99,7 +99,7 @@ function buildSystemPrompt(context) {
     "- If multiple possible agents, use disambiguate with candidates and no dispatch.",
     "- If user specifies a nickname for a new agent, include ops.launch with nickname so daemon can rename.",
     "- If user requests rename, use ops.rename with agent_id and nickname (do NOT launch).",
-    "- For scheduled follow-up (cron/corn), use ops.cron with operation=start and include every+target(s)+prompt.",
+    "- For scheduled follow-up (cron), use ops.cron with operation=start and include every+target(s)+prompt (or at for one-time).",
     "- To check scheduled tasks, use ops.cron with operation=list.",
     "- To stop scheduled tasks, use ops.cron with operation=stop and id (or id=all).",
     "- Use top-level assistant_call for project exploration, temporary shell tasks, and quick execution support.",

package/src/bus/index.js

@@ -308,9 +308,16 @@ class EventBus {
       const result = eventName === "message"
         ? await this.messageManager.send(target, message, publisher)
         : await this.messageManager.emit(target, eventName, data, publisher);
-      logOk(
-        `Message sent: seq=${result.seq} -> ${result.targets.join(", ")}`
-      );
+      const silent = options.silent === true;
+      if (!silent && eventName === "message") {
+        logOk(
+          `Message sent: seq=${result.seq} -> ${result.targets.join(", ")}`
+        );
+      } else if (!silent && process.env.UFOO_BUS_VERBOSE_EVENTS === "1") {
+        logInfo(
+          `Event sent: event=${eventName} seq=${result.seq} -> ${result.targets.join(", ")}`
+        );
+      }
       return result;
     } catch (err) {
       logError(err.message);

package/src/bus/inject.js

@@ -284,8 +284,11 @@ class Injector {
     // 读取 tty（tmux 需要）
     const tty = this.readTty(subscriber);
 
-    if (supportsNotifier) {
-      // 2. 尝试 tmux（无需权限）
+    // 2. 尝试 tmux（无需权限）
+    // Launch mode may be temporarily missing/stale (e.g. rejoin from non-interactive context).
+    // In that case still try tmux fallback by pane/tty.
+    const allowTmuxFallback = supportsNotifier || !launchMode || launchMode === "terminal" || launchMode === "tmux";
+    if (allowTmuxFallback) {
       const tmuxPane = meta.tmux_pane || this.getTmuxPane(subscriber);
       if (tmuxPane) {
         const paneExists = await this.checkTmuxPane(tmuxPane);
@@ -296,7 +299,7 @@ class Injector {
         }
       }
 
-      // 尝试通过 tty 查找 tmux pane
+      // Try resolving pane via tty when tmux pane metadata is missing.
       if (tty && isValidTty(tty)) {
         const fallbackPane = await this.findTmuxPaneByTty(tty);
         if (fallbackPane) {

package/src/bus/subscriber.js

@@ -161,7 +161,15 @@ class SubscriberManager {
       nicknameManager.setNickname(subscriber, finalNickname);
     }
 
-    const launchMode = options.launchMode || process.env.UFOO_LAUNCH_MODE || "";
+    const explicitLaunchMode = typeof options.launchMode === "string"
+      ? options.launchMode.trim()
+      : "";
+    const envLaunchMode = typeof process.env.UFOO_LAUNCH_MODE === "string"
+      ? process.env.UFOO_LAUNCH_MODE.trim()
+      : "";
+    const preservedLaunchMode = existingMeta?.launch_mode || "";
+    const inferredLaunchMode = process.env.TMUX_PANE ? "tmux" : "";
+    const launchMode = explicitLaunchMode || envLaunchMode || preservedLaunchMode || inferredLaunchMode;
     const overridePid = Number.isFinite(options.parentPid) && options.parentPid > 0
       ? options.parentPid
       : null;
@@ -184,6 +192,11 @@ class SubscriberManager {
     const preserved = existingMeta && typeof existingMeta === "object"
       ? { ...existingMeta }
       : {};
+    const explicitTmuxPane = typeof options.tmuxPane === "string" ? options.tmuxPane.trim() : "";
+    const envTmuxPane = typeof process.env.TMUX_PANE === "string" ? process.env.TMUX_PANE.trim() : "";
+    const preservedTmuxPane = typeof existingMeta?.tmux_pane === "string" ? existingMeta.tmux_pane.trim() : "";
+    const tmuxPane = explicitTmuxPane || envTmuxPane || preservedTmuxPane;
+
     this.busData.agents[subscriber] = {
       ...preserved,
       agent_type: agentType,
@@ -194,7 +207,7 @@ class SubscriberManager {
       pid: overridePid || getJoinedPid(),
       tty: finalTty,
       tty_shell_pid: ttyInfo?.shellPid || 0,
-      tmux_pane: options.tmuxPane || process.env.TMUX_PANE || "",
+      tmux_pane: tmuxPane,
       launch_mode: launchMode,
     };
 

package/src/chat/commandExecutor.js

@@ -69,6 +69,7 @@ function createCommandExecutor(options = {}) {
     createCronTask = () => null,
     listCronTasks = () => [],
     stopCronTask = () => false,
+    requestCron = null,
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     schedule = (fn, ms) => setTimeout(fn, ms),
   } = options;
@@ -419,9 +420,44 @@ function createCommandExecutor(options = {}) {
       .filter(Boolean);
   }
 
-  async function handleCornCommand(args = []) {
+  function parseCronAtMs(raw = "") {
+    const text = String(raw || "").trim();
+    if (!text) return 0;
+
+    if (/^\d+$/.test(text)) {
+      const value = Number.parseInt(text, 10);
+      if (!Number.isFinite(value) || value <= 0) return 0;
+      return text.length <= 10 ? value * 1000 : value;
+    }
+
+    const normalized = text.replace(/\//g, "-");
+    const directMatch = normalized.match(/^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2})(?::(\d{2}))?$/);
+    if (directMatch) {
+      const seconds = directMatch[3] || "00";
+      const parsed = Date.parse(`${directMatch[1]}T${directMatch[2]}:${seconds}`);
+      return Number.isFinite(parsed) ? parsed : 0;
+    }
+
+    const parsed = Date.parse(normalized);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+
+  function formatCronAt(ms = 0) {
+    const ts = Number(ms) || 0;
+    if (ts <= 0) return "";
+    const d = new Date(ts);
+    const pad = (v) => String(v).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  }
+
+  async function handleCronCommand(args = []) {
     const action = String(args[0] || "").trim().toLowerCase();
     if (action === "list" || action === "ls") {
+      if (typeof requestCron === "function") {
+        requestCron({ operation: "list" });
+        schedule(requestStatus, 200);
+        return;
+      }
       const tasks = Array.isArray(listCronTasks()) ? listCronTasks() : [];
       if (tasks.length === 0) {
         logMessage("system", "{cyan-fg}Cron:{/cyan-fg} none");
@@ -437,7 +473,12 @@ function createCommandExecutor(options = {}) {
     if (action === "stop" || action === "rm" || action === "remove") {
       const target = String(args[1] || "").trim();
       if (!target) {
-        logMessage("error", "{white-fg}✗{/white-fg} Usage: /corn stop <id|all>");
+        logMessage("error", "{white-fg}✗{/white-fg} Usage: /cron stop <id|all>");
+        return;
+      }
+      if (typeof requestCron === "function") {
+        requestCron({ operation: "stop", id: target });
+        schedule(requestStatus, 200);
         return;
       }
       if (target === "all") {
@@ -464,6 +505,16 @@ function createCommandExecutor(options = {}) {
     const intervalRaw = String(
       kv.every || kv.interval || kv.interval_ms || kv.ms || ""
     ).trim();
+    const atRaw = String(
+      kv.at ||
+      kv.once ||
+      kv.run_at ||
+      kv.runat ||
+      kv.datetime ||
+      kv.date_time ||
+      ((kv.date && kv.time) ? `${kv.date} ${kv.time}` : "") ||
+      ""
+    ).trim();
     const targetsRaw = String(
       kv.target || kv.targets || kv.agent || kv.agents || ""
     ).trim();
@@ -471,26 +522,66 @@ function createCommandExecutor(options = {}) {
       kv.prompt || kv.message || kv.msg || nonKvParts.join(" ") || ""
     ).trim();
 
-    if (!intervalRaw || !targetsRaw || !prompt) {
+    if ((!intervalRaw && !atRaw) || !targetsRaw || !prompt) {
       logMessage(
         "error",
-        "{white-fg}✗{/white-fg} Usage: /corn start every=<10s|5m> target=<agent1,agent2> prompt=\"...\""
+        "{white-fg}✗{/white-fg} Usage: /cron start every=<10s|5m> or at=\"YYYY-MM-DD HH:mm\" target=<agent1,agent2> prompt=\"...\""
       );
       return;
     }
 
-    const intervalMs = parseIntervalMs(intervalRaw);
-    if (!Number.isFinite(intervalMs) || intervalMs < 1000) {
+    if (intervalRaw && atRaw) {
+      logMessage("error", "{white-fg}✗{/white-fg} Use either every=... or at=..., not both");
+      return;
+    }
+
+    const intervalMs = intervalRaw ? parseIntervalMs(intervalRaw) : 0;
+    if (intervalRaw && (!Number.isFinite(intervalMs) || intervalMs < 1000)) {
       logMessage("error", "{white-fg}✗{/white-fg} Invalid interval (min 1s)");
       return;
     }
 
+    const atMs = atRaw ? parseCronAtMs(atRaw) : 0;
+    if (atRaw && (!Number.isFinite(atMs) || atMs <= 0)) {
+      logMessage("error", "{white-fg}✗{/white-fg} Invalid one-time schedule, use at=\"YYYY-MM-DD HH:mm\"");
+      return;
+    }
+    if (atMs > 0 && atMs <= Date.now()) {
+      logMessage("error", "{white-fg}✗{/white-fg} One-time schedule must be in the future");
+      return;
+    }
+
     const targets = parseCronTargets(targetsRaw);
     if (targets.length === 0) {
       logMessage("error", "{white-fg}✗{/white-fg} At least one target agent is required");
       return;
     }
 
+    if (typeof requestCron === "function") {
+      if (atMs > 0) {
+        requestCron({
+          operation: "start",
+          once_at_ms: atMs,
+          targets,
+          prompt,
+        });
+      } else {
+        requestCron({
+          operation: "start",
+          interval_ms: intervalMs,
+          targets,
+          prompt,
+        });
+      }
+      schedule(requestStatus, 200);
+      return;
+    }
+
+    if (atMs > 0) {
+      logMessage("error", "{white-fg}✗{/white-fg} One-time cron requires daemon-backed scheduler");
+      return;
+    }
+
     const task = createCronTask({
       intervalMs,
       targets,
@@ -503,7 +594,7 @@ function createCommandExecutor(options = {}) {
 
     logMessage(
       "system",
-      `{white-fg}✓{/white-fg} Cron started ${task.id}: every ${formatIntervalMs(intervalMs)} -> ${targets.join(", ")}`
+      `{white-fg}✓{/white-fg} Cron started ${task.id}: ${atMs > 0 ? `at ${formatCronAt(atMs)}` : `every ${formatIntervalMs(intervalMs)}`} -> ${targets.join(", ")}`
     );
   }
 
@@ -554,6 +645,39 @@ function createCommandExecutor(options = {}) {
     });
   }
 
+  async function handleUfooCommand(args = []) {
+    // Handle /ufoo command (session marker from daemon)
+    // When daemon sends /ufoo <marker>, we should just check for pending messages
+    if (args.length > 0) {
+      // This is a probe marker, check for pending messages
+      const subscriberId = process.env.UFOO_SUBSCRIBER_ID;
+      if (subscriberId) {
+        try {
+          const bus = createBus(projectRoot);
+          bus.ensureBus();
+          const pendingMessages = bus.checkMessages(subscriberId);
+          if (pendingMessages && pendingMessages.length > 0) {
+            logMessage("system", `{cyan-fg}[bus]{/cyan-fg} ${pendingMessages.length} pending message(s)`);
+          }
+        } catch {
+          // Ignore errors when checking messages
+        }
+      }
+      // Don't log anything else for probe markers
+      return;
+    }
+
+    // Without arguments, show ufoo protocol documentation
+    logMessage("system", "{cyan-fg}ufoo Protocol{/cyan-fg}");
+    logMessage("system", "");
+    logMessage("system", "This project uses ufoo for agent coordination:");
+    logMessage("system", "  • Context decisions: /ctx");
+    logMessage("system", "  • Event bus: /bus");
+    logMessage("system", "  • Initialize: /init");
+    logMessage("system", "");
+    logMessage("system", "For detailed documentation, see .ufoo/docs/");
+  }
+
   async function handleUcodeConfigCommand(args = []) {
     const first = String(args[0] || "").trim().toLowerCase();
     const hasInlineKv = args.some((item) => String(item || "").includes("="));
@@ -668,12 +792,15 @@ function createCommandExecutor(options = {}) {
       case "resume":
         await handleResumeCommand(args);
         return true;
-      case "corn":
-        await handleCornCommand(args);
+      case "cron":
+        await handleCronCommand(args);
         return true;
       case "settings":
         await handleSettingsCommand(args);
         return true;
+      case "ufoo":
+        await handleUfooCommand(args);
+        return true;
       default:
         logMessage("error", `{white-fg}✗{/white-fg} Unknown command: /${command}`);
         return true;
@@ -691,9 +818,10 @@ function createCommandExecutor(options = {}) {
     handleSkillsCommand,
     handleLaunchCommand,
     handleResumeCommand,
-    handleCornCommand,
+    handleCronCommand,
     handleSettingsCommand,
     handleUcodeConfigCommand,
+    handleUfooCommand,
   };
 }
 

package/src/chat/commands.js

@@ -27,7 +27,7 @@ const COMMAND_TREE = {
     },
   },
   "/doctor": { desc: "Health check diagnostics" },
-  "/corn": {
+  "/cron": {
     desc: "Cron scheduler operations",
     children: {
       start: { desc: "Create cron task" },
@@ -64,6 +64,7 @@ const COMMAND_TREE = {
     },
   },
   "/status": { desc: "Status display" },
+  "/ufoo": { desc: "ufoo protocol (session marker)" },
 };
 
 const COMMAND_ORDER = ["/launch", "/bus", "/ctx"];

package/src/chat/daemonMessageRouter.js

@@ -110,6 +110,46 @@ function createDaemonMessageRouter(options = {}) {
       }
     }
 
+    if (payload.cron && typeof payload.cron === "object") {
+      const cron = payload.cron;
+      const operation = String(cron.operation || "").toLowerCase();
+      if (!cron.ok) {
+        logMessage("error", `{white-fg}✗{/white-fg} ${escapeBlessed(cron.error || "cron failed")}`);
+      } else if (operation === "list" || operation === "ls") {
+        const tasks = Array.isArray(cron.tasks) ? cron.tasks : [];
+        if (tasks.length === 0) {
+          logMessage("system", "{cyan-fg}Cron:{/cyan-fg} none");
+        } else {
+          logMessage("system", `{cyan-fg}Cron:{/cyan-fg} ${tasks.length} task(s)`);
+          tasks.forEach((task) => {
+            const summary = task && (task.summary || task.id) ? (task.summary || task.id) : "";
+            if (summary) {
+              logMessage("system", `  • ${escapeBlessed(summary)}`);
+            }
+          });
+        }
+      } else if (operation === "start" && cron.task) {
+        const task = cron.task;
+        if (task.mode === "once") {
+          logMessage(
+            "system",
+            `{white-fg}✓{/white-fg} Cron scheduled ${escapeBlessed(task.id)} at ${escapeBlessed(task.onceAt || String(task.onceAtMs || ""))}`
+          );
+        } else {
+          logMessage(
+            "system",
+            `{white-fg}✓{/white-fg} Cron started ${escapeBlessed(task.id)}: every ${escapeBlessed(task.interval || String(task.intervalMs || ""))}`
+          );
+        }
+      } else if (operation === "stop") {
+        if (cron.id === "all") {
+          logMessage("system", `{white-fg}✓{/white-fg} Stopped ${Number(cron.stopped) || 0} cron task(s)`);
+        } else if (cron.id) {
+          logMessage("system", `{white-fg}✓{/white-fg} Stopped cron task ${escapeBlessed(cron.id)}`);
+        }
+      }
+    }
+
     if (payload.dispatch && payload.dispatch.length > 0) {
       const targets = payload.dispatch.map((d) => d.target || d).join(", ");
       logMessage("dispatch", `{white-fg}→{/white-fg} Dispatched to: ${escapeBlessed(targets)}`);