@femtomc/mu-agent 26.2.56 → 26.2.57

package/README.md

@@ -54,16 +54,16 @@ Current stack:
 
 ## Slash commands (operator-facing)
 
-- `/mu-status` — concise server status
-- `/mu-control` — active control-plane adapters and webhook routes
-- `/mu-setup` — adapter preflight
-- `/mu-setup plan <adapter>` — actionable wiring plan
-- `/mu-setup apply <adapter>` — guided config apply + control-plane reload
-- `/mu-setup verify [adapter]` — runtime verification for mounted routes
-- `/mu-setup <adapter>` — sends adapter setup brief to mu agent (`--no-agent` prints local guide)
-- `/mu-events [n]` / `/mu-events tail [n]` — event log tail
-- `/mu-events watch on|off` — toggle event watch widget
-- `/mu-brand on|off|toggle` — enable/disable UI branding
+- `/mu status` — concise server status
+- `/mu control` — active control-plane adapters and webhook routes
+- `/mu setup` — adapter preflight
+- `/mu setup plan <adapter>` — actionable wiring plan
+- `/mu setup apply <adapter>` — guided config apply + control-plane reload
+- `/mu setup verify [adapter]` — runtime verification for mounted routes
+- `/mu setup <adapter>` — sends adapter setup brief to mu agent (`--no-agent` prints local guide)
+- `/mu events [n]` / `/mu events tail [n]` — event log tail
+- `/mu events watch on|off` — toggle event watch widget
+- `/mu brand on|off|toggle` — enable/disable UI branding
 
 ## Tools (agent/operator-facing)
 

package/dist/extensions/branding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branding.d.ts","sourceRoot":"","sources":["../../src/extensions/branding.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AA+CpF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,YAAY,QA4NjD;AAED,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"branding.d.ts","sourceRoot":"","sources":["../../src/extensions/branding.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAgDpF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,YAAY,QA8NjD;AAED,eAAe,iBAAiB,CAAC"}

package/dist/extensions/branding.js

@@ -8,6 +8,7 @@
  * - Lightweight periodic status refresh (open/ready/control-plane)
  */
 import { basename } from "node:path";
+import { registerMuSubcommand } from "./mu-command-dispatcher.js";
 import { fetchMuStatus, muServerUrl } from "./shared.js";
 const EMPTY_SNAPSHOT = {
     openCount: 0,
@@ -61,7 +62,7 @@ export function brandingExtension(pi) {
                     : snapshot.controlPlaneActive
                         ? theme.fg("success", `cp ${snapshot.adapters.join(",") || "on"}`)
                         : theme.fg("muted", "cp off");
-                const line1 = `${theme.fg("accent", "μ")}${theme.fg("dim", " quick actions")}: ${theme.fg("muted", "/mu-status  /mu-control  /mu-setup  /mu-events")}`;
+                const line1 = `${theme.fg("accent", "μ")}${theme.fg("dim", " quick actions")}: ${theme.fg("muted", "/mu status  /mu control  /mu setup  /mu events")}`;
                 const line2 = `${theme.fg("dim", `open ${snapshot.openCount} · ready ${snapshot.readyCount}`)} · ${cpState}`;
                 return [truncateToWidth(line1, width), truncateToWidth(line2, width)];
             },
@@ -220,8 +221,10 @@ export function brandingExtension(pi) {
         footerRequestRender = null;
         activeCtx = null;
     });
-    pi.registerCommand("mu-brand", {
-        description: "Toggle mu TUI branding (`/mu-brand on|off|toggle`)",
+    registerMuSubcommand(pi, {
+        subcommand: "brand",
+        summary: "Toggle mu TUI branding",
+        usage: "/mu brand [on|off|toggle]",
         handler: async (args, ctx) => {
             const mode = args.trim().toLowerCase();
             if (mode === "on") {

package/dist/extensions/cron.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+export declare function cronExtension(pi: ExtensionAPI): void;
+export default cronExtension;
+//# sourceMappingURL=cron.d.ts.map

package/dist/extensions/cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["../../src/extensions/cron.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAiBlE,wBAAgB,aAAa,CAAC,EAAE,EAAE,YAAY,QAoK7C;AAED,eAAe,aAAa,CAAC"}

package/dist/extensions/cron.js

@@ -0,0 +1,187 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { clampInt, fetchMuJson, textResult, toJsonText } from "./shared.js";
+function trimOrNull(value) {
+    if (value == null)
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizedNumber(value) {
+    if (value == null || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return Math.trunc(value);
+}
+export function cronExtension(pi) {
+    const Params = Type.Object({
+        action: StringEnum(["status", "list", "get", "create", "update", "delete", "trigger", "enable", "disable"]),
+        program_id: Type.Optional(Type.String({ description: "Cron program ID" })),
+        title: Type.Optional(Type.String({ description: "Program title" })),
+        target_kind: Type.Optional(Type.String({ description: "Target kind (run|activity)" })),
+        run_job_id: Type.Optional(Type.String({ description: "Run job ID target" })),
+        run_root_issue_id: Type.Optional(Type.String({ description: "Run root issue ID target" })),
+        activity_id: Type.Optional(Type.String({ description: "Activity ID target" })),
+        schedule_kind: Type.Optional(Type.String({ description: "Schedule kind (at|every|cron)" })),
+        at_ms: Type.Optional(Type.Number({ description: "One-shot timestamp in epoch ms" })),
+        at: Type.Optional(Type.String({ description: "One-shot timestamp (ISO-8601)" })),
+        every_ms: Type.Optional(Type.Number({ description: "Fixed interval in ms" })),
+        anchor_ms: Type.Optional(Type.Number({ description: "Anchor timestamp for every schedules" })),
+        expr: Type.Optional(Type.String({ description: "Cron expression (5-field)" })),
+        tz: Type.Optional(Type.String({ description: "Optional IANA timezone for cron expressions" })),
+        reason: Type.Optional(Type.String({ description: "Execution reason" })),
+        enabled: Type.Optional(Type.Boolean({ description: "Enabled state" })),
+        schedule_filter: Type.Optional(Type.String({ description: "Filter list by schedule kind" })),
+        limit: Type.Optional(Type.Number({ description: "Max returned items for list" })),
+    });
+    pi.registerTool({
+        name: "mu_cron",
+        label: "Cron",
+        description: "Manage persistent cron programs. Actions: status, list, get, create, update, delete, trigger, enable, disable.",
+        parameters: Params,
+        async execute(_toolCallId, params) {
+            switch (params.action) {
+                case "status": {
+                    const payload = await fetchMuJson("/api/cron/status");
+                    return textResult(toJsonText(payload), { action: "status" });
+                }
+                case "list": {
+                    const query = new URLSearchParams();
+                    const targetKind = trimOrNull(params.target_kind);
+                    if (targetKind) {
+                        query.set("target_kind", targetKind);
+                    }
+                    if (typeof params.enabled === "boolean") {
+                        query.set("enabled", params.enabled ? "true" : "false");
+                    }
+                    const scheduleFilter = trimOrNull(params.schedule_filter) ?? trimOrNull(params.schedule_kind);
+                    if (scheduleFilter) {
+                        query.set("schedule_kind", scheduleFilter);
+                    }
+                    query.set("limit", String(clampInt(params.limit, 50, 1, 500)));
+                    const payload = await fetchMuJson(`/api/cron?${query.toString()}`);
+                    return textResult(toJsonText(payload), {
+                        action: "list",
+                        targetKind,
+                        enabled: params.enabled,
+                        scheduleFilter,
+                    });
+                }
+                case "get": {
+                    const programId = trimOrNull(params.program_id);
+                    if (!programId)
+                        return textResult("get requires program_id");
+                    const payload = await fetchMuJson(`/api/cron/${encodeURIComponent(programId)}`);
+                    return textResult(toJsonText(payload), { action: "get", programId });
+                }
+                case "create": {
+                    const title = trimOrNull(params.title);
+                    const targetKind = trimOrNull(params.target_kind);
+                    const scheduleKind = trimOrNull(params.schedule_kind);
+                    if (!title)
+                        return textResult("create requires title");
+                    if (!targetKind)
+                        return textResult("create requires target_kind (run|activity)");
+                    if (!scheduleKind)
+                        return textResult("create requires schedule_kind (at|every|cron)");
+                    const payload = await fetchMuJson("/api/cron/create", {
+                        method: "POST",
+                        body: {
+                            title,
+                            target_kind: targetKind,
+                            run_job_id: trimOrNull(params.run_job_id),
+                            run_root_issue_id: trimOrNull(params.run_root_issue_id),
+                            activity_id: trimOrNull(params.activity_id),
+                            schedule_kind: scheduleKind,
+                            at_ms: normalizedNumber(params.at_ms),
+                            at: trimOrNull(params.at),
+                            every_ms: normalizedNumber(params.every_ms),
+                            anchor_ms: normalizedNumber(params.anchor_ms),
+                            expr: trimOrNull(params.expr),
+                            tz: trimOrNull(params.tz),
+                            reason: trimOrNull(params.reason),
+                            enabled: typeof params.enabled === "boolean" ? params.enabled : undefined,
+                        },
+                    });
+                    return textResult(toJsonText(payload), {
+                        action: "create",
+                        title,
+                        targetKind,
+                        scheduleKind,
+                    });
+                }
+                case "update": {
+                    const programId = trimOrNull(params.program_id);
+                    if (!programId)
+                        return textResult("update requires program_id");
+                    const payload = await fetchMuJson("/api/cron/update", {
+                        method: "POST",
+                        body: {
+                            program_id: programId,
+                            title: trimOrNull(params.title),
+                            target_kind: trimOrNull(params.target_kind),
+                            run_job_id: trimOrNull(params.run_job_id),
+                            run_root_issue_id: trimOrNull(params.run_root_issue_id),
+                            activity_id: trimOrNull(params.activity_id),
+                            schedule_kind: trimOrNull(params.schedule_kind),
+                            at_ms: normalizedNumber(params.at_ms),
+                            at: trimOrNull(params.at),
+                            every_ms: normalizedNumber(params.every_ms),
+                            anchor_ms: normalizedNumber(params.anchor_ms),
+                            expr: trimOrNull(params.expr),
+                            tz: trimOrNull(params.tz),
+                            reason: trimOrNull(params.reason),
+                            enabled: typeof params.enabled === "boolean" ? params.enabled : undefined,
+                        },
+                    });
+                    return textResult(toJsonText(payload), { action: "update", programId });
+                }
+                case "delete": {
+                    const programId = trimOrNull(params.program_id);
+                    if (!programId)
+                        return textResult("delete requires program_id");
+                    const payload = await fetchMuJson("/api/cron/delete", {
+                        method: "POST",
+                        body: {
+                            program_id: programId,
+                        },
+                    });
+                    return textResult(toJsonText(payload), { action: "delete", programId });
+                }
+                case "trigger": {
+                    const programId = trimOrNull(params.program_id);
+                    if (!programId)
+                        return textResult("trigger requires program_id");
+                    const payload = await fetchMuJson("/api/cron/trigger", {
+                        method: "POST",
+                        body: {
+                            program_id: programId,
+                            reason: trimOrNull(params.reason),
+                        },
+                    });
+                    return textResult(toJsonText(payload), { action: "trigger", programId });
+                }
+                case "enable":
+                case "disable": {
+                    const programId = trimOrNull(params.program_id);
+                    if (!programId)
+                        return textResult(`${params.action} requires program_id`);
+                    const payload = await fetchMuJson("/api/cron/update", {
+                        method: "POST",
+                        body: {
+                            program_id: programId,
+                            enabled: params.action === "enable",
+                        },
+                    });
+                    return textResult(toJsonText(payload), {
+                        action: params.action,
+                        programId,
+                    });
+                }
+                default:
+                    return textResult(`unknown action: ${params.action}`);
+            }
+        },
+    });
+}
+export default cronExtension;

package/dist/extensions/event-log.d.ts

@@ -2,8 +2,8 @@
  * mu-event-log — Event stream helper for mu serve.
  *
  * - Status line with last event type and tail count
- * - Optional watch widget below editor (`/mu-events watch on|off`)
- * - Command for quick tail inspection (`/mu-events [n]` or `/mu-events tail [n]`)
+ * - Optional watch widget below editor (`/mu events watch on|off`)
+ * - Command for quick tail inspection (`/mu events [n]` or `/mu events tail [n]`)
  */
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 export declare function eventLogExtension(pi: ExtensionAPI): void;

package/dist/extensions/event-log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-log.d.ts","sourceRoot":"","sources":["../../src/extensions/event-log.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAgCpF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,YAAY,QAgHjD;AAED,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"event-log.d.ts","sourceRoot":"","sources":["../../src/extensions/event-log.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAiCpF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,YAAY,QAkHjD;AAED,eAAe,iBAAiB,CAAC"}

package/dist/extensions/event-log.js

@@ -2,9 +2,10 @@
  * mu-event-log — Event stream helper for mu serve.
  *
  * - Status line with last event type and tail count
- * - Optional watch widget below editor (`/mu-events watch on|off`)
- * - Command for quick tail inspection (`/mu-events [n]` or `/mu-events tail [n]`)
+ * - Optional watch widget below editor (`/mu events watch on|off`)
+ * - Command for quick tail inspection (`/mu events [n]` or `/mu events tail [n]`)
  */
+import { registerMuSubcommand } from "./mu-command-dispatcher.js";
 import { clampInt, fetchMuJson, muServerUrl } from "./shared.js";
 function eventTime(tsMs) {
     return new Date(tsMs).toLocaleTimeString();
@@ -96,8 +97,10 @@ export function eventLogExtension(pi) {
         stopPolling();
         activeCtx = null;
     });
-    pi.registerCommand("mu-events", {
-        description: "Inspect events (`/mu-events [n]`, `/mu-events tail [n]`, `/mu-events watch on|off`)",
+    registerMuSubcommand(pi, {
+        subcommand: "events",
+        summary: "Inspect event tails and toggle the watch widget",
+        usage: "/mu events [n] | /mu events tail [n] | /mu events watch on|off",
         handler: async (args, ctx) => {
             const tokens = args
                 .trim()

package/dist/extensions/index.d.ts

@@ -1,5 +1,6 @@
 export { activitiesExtension } from "./activities.js";
 export { brandingExtension } from "./branding.js";
+export { cronExtension } from "./cron.js";
 export { eventLogExtension } from "./event-log.js";
 export { heartbeatsExtension } from "./heartbeats.js";
 export { messagingSetupExtension } from "./messaging-setup.js";

package/dist/extensions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extensions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,kCAAkC,EAAE,MAAM,kCAAkC,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AACvF,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AA0B1E;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,UAE/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,UAElC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extensions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,kCAAkC,EAAE,MAAM,kCAAkC,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AACvF,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AA2B1E;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,UAE/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,UAElC,CAAC"}

package/dist/extensions/index.js

@@ -1,5 +1,6 @@
 export { activitiesExtension } from "./activities.js";
 export { brandingExtension } from "./branding.js";
+export { cronExtension } from "./cron.js";
 export { eventLogExtension } from "./event-log.js";
 export { heartbeatsExtension } from "./heartbeats.js";
 export { messagingSetupExtension } from "./messaging-setup.js";
@@ -16,6 +17,7 @@ const SERVE_EXTENSION_MODULE_BASENAMES = [
     "orchestration-runs",
     "activities",
     "heartbeats",
+    "cron",
 ];
 const OPERATOR_EXTENSION_MODULE_BASENAMES = [
     "branding",

package/dist/extensions/messaging-setup.d.ts

@@ -2,7 +2,7 @@
  * mu-messaging-setup — Adapter configuration diagnostics + guided setup.
  *
  * Goals:
- * - Make `/mu-setup <adapter>` hand setup context to the active mu agent.
+ * - Make `/mu setup <adapter>` hand setup context to the active mu agent.
  * - Keep configuration in `.mu/config.json` (no process.env mutations).
  * - Support plan/apply/verify workflow with in-process control-plane reload.
  */

package/dist/extensions/messaging-setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messaging-setup.d.ts","sourceRoot":"","sources":["../../src/extensions/messaging-setup.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,YAAY,EAA6C,MAAM,+BAA+B,CAAC;AAwpC7G,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,YAAY,QAwPvD;AAED,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"messaging-setup.d.ts","sourceRoot":"","sources":["../../src/extensions/messaging-setup.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,YAAY,EAA6C,MAAM,+BAA+B,CAAC;AAypC7G,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,YAAY,QAyPvD;AAED,eAAe,uBAAuB,CAAC"}

package/dist/extensions/messaging-setup.js

@@ -2,13 +2,14 @@
  * mu-messaging-setup — Adapter configuration diagnostics + guided setup.
  *
  * Goals:
- * - Make `/mu-setup <adapter>` hand setup context to the active mu agent.
+ * - Make `/mu setup <adapter>` hand setup context to the active mu agent.
  * - Keep configuration in `.mu/config.json` (no process.env mutations).
  * - Support plan/apply/verify workflow with in-process control-plane reload.
  */
 import { StringEnum } from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
 import { loadBundledPrompt } from "../default_prompts.js";
+import { registerMuSubcommand } from "./mu-command-dispatcher.js";
 import { fetchMuJson, fetchMuStatus, muServerUrl, textResult, toJsonText } from "./shared.js";
 const MESSAGING_SETUP_BRIEF_TEMPLATE = loadBundledPrompt("skills/messaging-setup-brief.md");
 function interpolateTemplate(template, vars) {
@@ -31,7 +32,7 @@ const ADAPTERS = [
             "Copy Signing Secret into .mu/config.json → control_plane.adapters.slack.signing_secret.",
             "Create a Slash Command (e.g. /mu) with Request URL <public-base-url>/webhooks/slack.",
             "Install/reinstall app after command changes.",
-            "Run /mu in Slack, then /mu-setup verify slack.",
+            "Run /mu in Slack, then /mu setup verify slack.",
         ],
     },
     {
@@ -49,7 +50,7 @@ const ADAPTERS = [
             "Create/open app in Discord Developer Portal.",
             "Copy Interaction Public Key into .mu/config.json → control_plane.adapters.discord.signing_secret.",
             "Set Interactions Endpoint URL to <public-base-url>/webhooks/discord.",
-            "Run a Discord command interaction, then /mu-setup verify discord.",
+            "Run a Discord command interaction, then /mu setup verify discord.",
         ],
     },
     {
@@ -79,7 +80,7 @@ const ADAPTERS = [
             "Call Telegram setWebhook using URL <public-base-url>/webhooks/telegram and matching secret_token.",
             "Link your Telegram identity to control-plane policy (mu control link --channel telegram --actor-id <telegram-user-id> --tenant-id telegram-bot --role <viewer|contributor|operator>).",
             "Optionally set control_plane.adapters.telegram.bot_username.",
-            "Send /mu in Telegram chat, then /mu-setup verify telegram.",
+            "Send /mu in Telegram chat, then /mu setup verify telegram.",
         ],
     },
     {
@@ -251,7 +252,7 @@ function nextStepForState(opts) {
         case "active":
             return "No action needed. Adapter is mounted and receiving webhooks.";
         case "configured_not_active":
-            return "Run `/mu-setup apply <adapter>` to trigger in-process control-plane reload.";
+            return "Run `/mu setup apply <adapter>` to trigger in-process control-plane reload.";
         case "missing_config":
             return `Set required config fields: ${opts.missing.join(", ")}.`;
         case "planned":
@@ -383,7 +384,7 @@ function setupGuide(checks, adapterId) {
     return [
         "# Messaging Integration Setup",
         "",
-        "Use `/mu-setup <adapter>` to hand setup context to mu agent.",
+        "Use `/mu setup <adapter>` to hand setup context to mu agent.",
         "Config source of truth is `.mu/config.json`.",
         "",
         ...sections,
@@ -402,15 +403,15 @@ function buildPlan(check, publicBaseUrl) {
     else {
         if (check.missing.length > 0) {
             steps.push(`Set required config fields: ${check.missing.join(", ")}.`);
-            steps.push(`Run /mu-setup apply ${check.id} to write config and reload control-plane.`);
+            steps.push(`Run /mu setup apply ${check.id} to write config and reload control-plane.`);
         }
         if (check.state === "configured_not_active") {
-            steps.push(`Run /mu-setup apply ${check.id} to trigger control-plane reload.`);
+            steps.push(`Run /mu setup apply ${check.id} to trigger control-plane reload.`);
         }
         if (webhookUrl) {
             steps.push(`Configure provider webhook/inbound URL to: ${webhookUrl}`);
         }
-        steps.push(`Run verification: /mu-setup verify ${check.id}${normalizedBase ? ` --public-base-url ${normalizedBase}` : ""}`);
+        steps.push(`Run verification: /mu setup verify ${check.id}${normalizedBase ? ` --public-base-url ${normalizedBase}` : ""}`);
     }
     return {
         id: check.id,
@@ -423,8 +424,8 @@ function buildPlan(check, publicBaseUrl) {
         missing_required_fields: check.missing,
         steps,
         commands: {
-            apply: `/mu-setup apply ${check.id}`,
-            verify: `/mu-setup verify ${check.id}`,
+            apply: `/mu setup apply ${check.id}`,
+            verify: `/mu setup verify ${check.id}`,
         },
     };
 }
@@ -702,7 +703,7 @@ function verifyText(result) {
         lines.push(`   next: ${check.next_step}`);
     }
     if (!result.ok) {
-        lines.push("", "Tip: run `/mu-setup plan <adapter>` for exact remediation steps.");
+        lines.push("", "Tip: run `/mu setup plan <adapter>` for exact remediation steps.");
     }
     return lines.join("\n");
 }
@@ -853,7 +854,7 @@ function buildAgentSetupPrompt(opts) {
         missing_fields: opts.check.missing.join(", ") || "(none)",
         provider_steps: adapter.providerSetupSteps.map((step, index) => `${index + 1}. ${step}`).join("\n"),
         field_status: adapterFieldStatusLines(adapter, opts.check).join("\n"),
-        verify_command: `/mu-setup verify ${adapter.id}${verifyFlag}`,
+        verify_command: `/mu setup verify ${adapter.id}${verifyFlag}`,
     });
 }
 function dispatchSetupPromptToAgent(pi, ctx, prompt) {
@@ -1023,7 +1024,7 @@ export function messagingSetupExtension(pi) {
                     const overrides = params.fields ?? {};
                     const stillMissing = check.missing.filter((field) => !(field in overrides));
                     if (stillMissing.length > 0) {
-                        return textResult(`Cannot apply ${adapterId}: missing required config fields (${stillMissing.join(", ")}). Pass them via the fields parameter or use /mu-setup apply ${adapterId} for guided input.`, { adapter: adapterId, missing_required_fields: stillMissing });
+                        return textResult(`Cannot apply ${adapterId}: missing required config fields (${stillMissing.join(", ")}). Pass them via the fields parameter or use /mu setup apply ${adapterId} for guided input.`, { adapter: adapterId, missing_required_fields: stillMissing });
                     }
                     const outcome = await applyAdapterConfig({
                         adapterId,
@@ -1057,12 +1058,14 @@ export function messagingSetupExtension(pi) {
             }
         },
     });
-    pi.registerCommand("mu-setup", {
-        description: "Messaging setup workflow (`/mu-setup slack`, `/mu-setup plan <adapter>`, `/mu-setup apply <adapter>`, `/mu-setup verify [adapter]`)",
+    registerMuSubcommand(pi, {
+        subcommand: "setup",
+        summary: "Messaging adapter setup workflow (preflight/guide/plan/apply/verify)",
+        usage: "/mu setup [preflight|guide|plan|apply|verify] [adapter] [--public-base-url URL] [--agent|--no-agent]",
         handler: async (args, ctx) => {
             const parsed = parseSetupCommandArgs(args);
             if (parsed.error) {
-                ctx.ui.notify(`${parsed.error}. Usage: /mu-setup [preflight|guide|plan|apply|verify] [adapter] [--public-base-url URL] [--agent|--no-agent]`, "error");
+                ctx.ui.notify(`${parsed.error}. Usage: /mu setup [preflight|guide|plan|apply|verify] [adapter] [--public-base-url URL] [--agent|--no-agent]`, "error");
                 return;
             }
             switch (parsed.action) {
@@ -1121,7 +1124,7 @@ export function messagingSetupExtension(pi) {
                 }
                 case "apply": {
                     if (!parsed.adapterId) {
-                        ctx.ui.notify("apply requires adapter. Example: /mu-setup apply slack", "error");
+                        ctx.ui.notify("apply requires adapter. Example: /mu setup apply slack", "error");
                         return;
                     }
                     const text = await runInteractiveApply(ctx, parsed.adapterId);

package/dist/extensions/mu-command-dispatcher.d.ts

@@ -0,0 +1,11 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+export type MuSubcommandHandler = (args: string, ctx: ExtensionCommandContext) => Promise<void> | void;
+export type MuSubcommandRegistration = {
+    subcommand: string;
+    summary: string;
+    usage: string;
+    aliases?: string[];
+    handler: MuSubcommandHandler;
+};
+export declare function registerMuSubcommand(pi: ExtensionAPI, registration: MuSubcommandRegistration): void;
+//# sourceMappingURL=mu-command-dispatcher.d.ts.map

package/dist/extensions/mu-command-dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mu-command-dispatcher.d.ts","sourceRoot":"","sources":["../../src/extensions/mu-command-dispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE3F,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,uBAAuB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEvG,MAAM,MAAM,wBAAwB,GAAG;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,mBAAmB,CAAC;CAC7B,CAAC;AAiIF,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,wBAAwB,GAAG,IAAI,CAsDnG"}

package/dist/extensions/mu-command-dispatcher.js

@@ -0,0 +1,143 @@
+const DISPATCHER_STATES = new WeakMap();
+const RESERVED_SUBCOMMANDS = new Set(["help", "?"]);
+function normalizeSubcommand(value) {
+    return value.trim().toLowerCase();
+}
+function isValidSubcommandToken(value) {
+    return /^[a-z][a-z0-9_-]*$/.test(value);
+}
+function subcommandUsageSummary(entry) {
+    const aliasSuffix = entry.aliases && entry.aliases.length > 0 ? ` (aliases: ${entry.aliases.join(", ")})` : "";
+    return `- ${entry.usage} — ${entry.summary}${aliasSuffix}`;
+}
+function renderSubcommandCatalog(state) {
+    if (state.entries.size === 0) {
+        return ["No /mu subcommands are currently registered.", "", "Try again after extensions finish loading."].join("\n");
+    }
+    const entries = [...state.entries.values()].sort((left, right) => left.normalizedSubcommand.localeCompare(right.normalizedSubcommand));
+    const lines = ["Usage: /mu <subcommand> [args]", "", "Subcommands:"];
+    for (const entry of entries) {
+        lines.push(subcommandUsageSummary(entry));
+    }
+    lines.push("", "Run `/mu help <subcommand>` for focused usage.");
+    return lines.join("\n");
+}
+function renderSubcommandHelp(entry) {
+    const lines = [entry.summary, "", `Usage: ${entry.usage}`];
+    if (entry.aliases && entry.aliases.length > 0) {
+        lines.push(`Aliases: ${entry.aliases.map((alias) => `/mu ${alias}`).join(", ")}`);
+    }
+    return lines.join("\n");
+}
+function parseInvocation(args) {
+    const trimmed = args.trim();
+    if (trimmed.length === 0) {
+        return { subcommand: "", remainder: "" };
+    }
+    const boundary = trimmed.search(/\s/);
+    if (boundary === -1) {
+        return { subcommand: trimmed, remainder: "" };
+    }
+    return {
+        subcommand: trimmed.slice(0, boundary),
+        remainder: trimmed.slice(boundary + 1).trim(),
+    };
+}
+function resolveEntry(state, token) {
+    const normalized = normalizeSubcommand(token);
+    if (!normalized)
+        return null;
+    const canonical = state.aliases.get(normalized) ?? normalized;
+    return state.entries.get(canonical) ?? null;
+}
+function ensureDispatcher(pi) {
+    const existing = DISPATCHER_STATES.get(pi);
+    if (existing) {
+        return existing;
+    }
+    const state = {
+        entries: new Map(),
+        aliases: new Map(),
+    };
+    DISPATCHER_STATES.set(pi, state);
+    pi.registerCommand("mu", {
+        description: "mu command dispatcher (`/mu <subcommand> ...`)",
+        handler: async (args, ctx) => {
+            const parsed = parseInvocation(args);
+            if (!parsed.subcommand) {
+                ctx.ui.notify(renderSubcommandCatalog(state), "info");
+                return;
+            }
+            const normalized = normalizeSubcommand(parsed.subcommand);
+            if (normalized === "help" || normalized === "?") {
+                if (!parsed.remainder) {
+                    ctx.ui.notify(renderSubcommandCatalog(state), "info");
+                    return;
+                }
+                const detail = resolveEntry(state, parsed.remainder.split(/\s+/)[0] ?? "");
+                if (!detail) {
+                    ctx.ui.notify(`Unknown mu subcommand: ${parsed.remainder}\n\n${renderSubcommandCatalog(state)}`, "error");
+                    return;
+                }
+                ctx.ui.notify(renderSubcommandHelp(detail), "info");
+                return;
+            }
+            const entry = resolveEntry(state, parsed.subcommand);
+            if (!entry) {
+                ctx.ui.notify(`Unknown mu subcommand: ${parsed.subcommand}\n\n${renderSubcommandCatalog(state)}`, "error");
+                return;
+            }
+            await entry.handler(parsed.remainder, ctx);
+        },
+    });
+    return state;
+}
+export function registerMuSubcommand(pi, registration) {
+    const state = ensureDispatcher(pi);
+    const normalizedSubcommand = normalizeSubcommand(registration.subcommand);
+    if (!isValidSubcommandToken(normalizedSubcommand)) {
+        throw new Error(`Invalid mu subcommand: ${registration.subcommand}`);
+    }
+    if (RESERVED_SUBCOMMANDS.has(normalizedSubcommand)) {
+        throw new Error(`Reserved mu subcommand: ${registration.subcommand}`);
+    }
+    if (!registration.usage.startsWith("/mu ")) {
+        throw new Error(`mu subcommand usage must start with '/mu ': ${registration.usage}`);
+    }
+    const normalizedAliases = (registration.aliases ?? [])
+        .map((alias) => normalizeSubcommand(alias))
+        .filter((alias) => alias.length > 0 && alias !== normalizedSubcommand);
+    for (const alias of normalizedAliases) {
+        if (!isValidSubcommandToken(alias)) {
+            throw new Error(`Invalid mu subcommand alias: ${alias}`);
+        }
+        if (RESERVED_SUBCOMMANDS.has(alias)) {
+            throw new Error(`Reserved mu subcommand alias: ${alias}`);
+        }
+    }
+    const existing = state.entries.get(normalizedSubcommand);
+    if (existing) {
+        for (const alias of existing.normalizedAliases) {
+            state.aliases.delete(alias);
+        }
+    }
+    for (const alias of normalizedAliases) {
+        const occupiedBy = state.aliases.get(alias);
+        if (occupiedBy && occupiedBy !== normalizedSubcommand) {
+            throw new Error(`mu subcommand alias '${alias}' is already registered by '${occupiedBy}'`);
+        }
+        if (state.entries.has(alias) && alias !== normalizedSubcommand) {
+            throw new Error(`mu subcommand alias '${alias}' conflicts with existing subcommand`);
+        }
+    }
+    const entry = {
+        ...registration,
+        normalizedSubcommand,
+        normalizedAliases,
+    };
+    state.entries.set(normalizedSubcommand, entry);
+    state.aliases.set(normalizedSubcommand, normalizedSubcommand);
+    for (const alias of normalizedAliases) {
+        state.aliases.set(alias, normalizedSubcommand);
+    }
+}

package/dist/extensions/server-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-tools.d.ts","sourceRoot":"","sources":["../../src/extensions/server-tools.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAoFlE,MAAM,MAAM,wBAAwB,GAAG;IACtC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC,CAAC;AAuXF,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,GAAE,wBAA6B,QAQzF;AAED,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,YAAY,QAS5D;AAED,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"server-tools.d.ts","sourceRoot":"","sources":["../../src/extensions/server-tools.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAqFlE,MAAM,MAAM,wBAAwB,GAAG;IACtC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC,CAAC;AA2XF,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,GAAE,wBAA6B,QAQzF;AAED,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,YAAY,QAS5D;AAED,eAAe,oBAAoB,CAAC"}

package/dist/extensions/server-tools.js

@@ -5,6 +5,7 @@
  */
 import { StringEnum } from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
+import { registerMuSubcommand } from "./mu-command-dispatcher.js";
 import { clampInt, fetchMuJson, fetchMuStatus, muServerUrl, textResult, toJsonText, } from "./shared.js";
 function trimOrNull(value) {
     if (value == null)
@@ -376,8 +377,10 @@ function registerServerTools(pi, opts) {
             }
         },
     });
-    pi.registerCommand("mu-status", {
-        description: "Show concise mu server status",
+    registerMuSubcommand(pi, {
+        subcommand: "status",
+        summary: "Show concise mu server status",
+        usage: "/mu status",
         handler: async (_args, ctx) => {
             try {
                 const status = await fetchMuStatus();
@@ -388,8 +391,10 @@ function registerServerTools(pi, opts) {
             }
         },
     });
-    pi.registerCommand("mu-control", {
-        description: "Show control-plane adapter/runtime status",
+    registerMuSubcommand(pi, {
+        subcommand: "control",
+        summary: "Show control-plane adapter/runtime status",
+        usage: "/mu control",
         handler: async (_args, ctx) => {
             try {
                 const status = await fetchMuStatus();
@@ -414,7 +419,7 @@ export function serverToolsExtension(pi, opts = {}) {
     registerServerTools(pi, {
         allowForumPost: opts.allowForumPost ?? true,
         toolIntroLine: opts.toolIntroLine ??
-            "Tools: mu_status, mu_control_plane, mu_issues, mu_forum, mu_events, mu_runs, mu_activities, mu_heartbeats, mu_identity.",
+            "Tools: mu_status, mu_control_plane, mu_issues, mu_forum, mu_events, mu_runs, mu_activities, mu_heartbeats, mu_cron, mu_identity.",
         extraSystemPromptLines: opts.extraSystemPromptLines ?? [],
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@femtomc/mu-agent",
-	"version": "26.2.56",
+	"version": "26.2.57",
 	"description": "Shared agent runtime for mu chat, orchestration roles, and serve extensions.",
 	"keywords": [
 		"mu",
@@ -23,7 +23,7 @@
 		"prompts/**"
 	],
 	"dependencies": {
-		"@femtomc/mu-core": "26.2.54",
+		"@femtomc/mu-core": "workspace:*",
 		"@mariozechner/pi-agent-core": "^0.52.12",
 		"@mariozechner/pi-ai": "^0.52.12",
 		"@mariozechner/pi-coding-agent": "^0.52.12",

package/prompts/roles/operator.md

@@ -22,6 +22,7 @@ You also have access to specialized read/diagnostic tools:
 - `mu_runs`
 - `mu_activities`
 - `mu_heartbeats`
+- `mu_cron`
 - `mu_messaging_setup`
 
 Hard Constraints: