@femtomc/mu-agent 26.2.55 → 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;AAyiC7G,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,YAAY,QA0PvD;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}`,
         },
     };
 }
@@ -452,6 +453,62 @@ function planText(plan) {
 function planSummary(plans) {
     return plans.map((plan) => planText(plan)).join("\n\n");
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isControlPlaneGenerationIdentity(value) {
+    if (!isRecord(value))
+        return false;
+    return typeof value.generation_id === "string" && typeof value.generation_seq === "number";
+}
+function isControlPlaneReloadGenerationSummary(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.attempt_id !== "string")
+        return false;
+    if (typeof value.coalesced !== "boolean")
+        return false;
+    if (value.from_generation !== null && !isControlPlaneGenerationIdentity(value.from_generation))
+        return false;
+    if (!isControlPlaneGenerationIdentity(value.to_generation))
+        return false;
+    if (value.active_generation !== null && !isControlPlaneGenerationIdentity(value.active_generation))
+        return false;
+    return value.outcome === "success" || value.outcome === "failure";
+}
+function parseControlPlaneReloadApiResponse(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {
+            response: null,
+            error: "control-plane reload returned invalid JSON response",
+        };
+    }
+    if (!isRecord(parsed)) {
+        return {
+            response: null,
+            error: "control-plane reload returned non-object payload",
+        };
+    }
+    if (!isControlPlaneReloadGenerationSummary(parsed.generation)) {
+        return {
+            response: null,
+            error: "control-plane reload response missing generation metadata (expected generation-scoped contract)",
+        };
+    }
+    const parsedRecord = parsed;
+    const response = {
+        ...parsed,
+        telegram_generation: parsedRecord.telegram_generation ?? null,
+    };
+    return {
+        response,
+        error: null,
+    };
+}
 async function reloadControlPlaneInProcess(reason) {
     const base = muServerUrl();
     if (!base) {
@@ -468,18 +525,27 @@ async function reloadControlPlaneInProcess(reason) {
             body: JSON.stringify({ reason }),
         });
         const raw = await response.text();
-        let parsed = null;
-        try {
-            parsed = JSON.parse(raw);
+        const parsedResult = parseControlPlaneReloadApiResponse(raw);
+        const parsed = parsedResult.response;
+        if (parsedResult.error) {
+            return {
+                ok: false,
+                response: null,
+                error: parsedResult.error,
+            };
         }
-        catch {
-            parsed = null;
+        if (!parsed) {
+            return {
+                ok: false,
+                response: null,
+                error: "control-plane reload response missing payload",
+            };
         }
-        if (!response.ok || !parsed?.ok) {
+        if (!response.ok || !parsed.ok) {
             return {
                 ok: false,
                 response: parsed,
-                error: parsed?.error ?? `control-plane reload failed (${response.status})`,
+                error: parsed.error ?? `control-plane reload failed (${response.status})`,
             };
         }
         return {
@@ -496,6 +562,22 @@ async function reloadControlPlaneInProcess(reason) {
         };
     }
 }
+function reloadOutcomeSummary(reload) {
+    if (!reload.ok) {
+        return `Control-plane reload failed: ${reload.error ?? "unknown error"}.`;
+    }
+    const response = reload.response;
+    if (!response) {
+        return "Control-plane reload failed: missing reload response payload.";
+    }
+    const adapters = response.control_plane?.adapters.join(", ") || "(none)";
+    const generationSummary = `${response.generation.outcome} (${response.generation.active_generation?.generation_id ?? response.generation.to_generation.generation_id})`;
+    const telegramRollbackTrigger = response.telegram_generation?.rollback.trigger;
+    const telegramNote = response.telegram_generation?.handled && telegramRollbackTrigger
+        ? ` rollback_trigger=${telegramRollbackTrigger}`
+        : "";
+    return `Control-plane reloaded in-process. Active adapters: ${adapters}. Generation: ${generationSummary}.${telegramNote}`;
+}
 function patchForAdapterValues(adapterId, values) {
     switch (adapterId) {
         case "slack":
@@ -621,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");
 }
@@ -772,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) {
@@ -846,9 +928,7 @@ async function runInteractiveApply(ctx, adapterId) {
     const lines = [
         `Updated config fields: ${outcome.updated_fields.join(", ") || "(none)"}`,
         `Config path: ${outcome.config_path ?? runtime.configPath ?? "(unknown)"}`,
-        outcome.reload.ok
-            ? `Control-plane reloaded in-process. Active adapters: ${outcome.reload.response?.control_plane?.adapters.join(", ") || "(none)"}.`
-            : `Control-plane reload failed: ${outcome.reload.error ?? "unknown error"}.`,
+        reloadOutcomeSummary(outcome.reload),
         "",
         verifyText(verify),
     ];
@@ -944,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,
@@ -959,9 +1039,7 @@ export function messagingSetupExtension(pi) {
                     const lines = [
                         `Updated config fields: ${outcome.updated_fields.join(", ") || "(none)"}`,
                         `Config path: ${outcome.config_path ?? runtime.configPath ?? "(unknown)"}`,
-                        outcome.reload.ok
-                            ? `Control-plane reloaded in-process. Active adapters: ${outcome.reload.response?.control_plane?.adapters.join(", ") || "(none)"}.`
-                            : `Control-plane reload failed: ${outcome.reload.error ?? "unknown error"}.`,
+                        reloadOutcomeSummary(outcome.reload),
                         "",
                         verifyText(verify),
                     ];
@@ -980,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) {
@@ -1044,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;AAgElE,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;AAoXF,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)
@@ -21,17 +22,33 @@ function cpRoutesFromStatus(routes, adapters) {
         route: `/webhooks/${name}`,
     }));
 }
+function generationSummary(generation) {
+    const active = generation.active_generation?.generation_id ?? "(none)";
+    const pending = generation.pending_reload
+        ? `${generation.pending_reload.attempt_id}:${generation.pending_reload.state}`
+        : "(none)";
+    const last = generation.last_reload
+        ? `${generation.last_reload.attempt_id}:${generation.last_reload.state}`
+        : "(none)";
+    return `generation: active=${active} pending=${pending} last=${last}`;
+}
+function observabilitySummary(counters) {
+    return `observability: reload_success=${counters.reload_success_total} reload_failure=${counters.reload_failure_total} duplicate=${counters.duplicate_signal_total} drop=${counters.drop_signal_total}`;
+}
 function summarizeStatus(status) {
-    const cp = status.control_plane ?? { active: false, adapters: [], routes: [] };
+    const cp = status.control_plane;
     const routes = cpRoutesFromStatus(cp.routes, cp.adapters);
     const routeText = routes.length > 0 ? routes.map((entry) => `${entry.name}:${entry.route}`).join(", ") : "(none)";
-    return [
+    const lines = [
         `repo: ${status.repo_root}`,
         `issues: open=${status.open_count} ready=${status.ready_count}`,
         `control_plane: ${cp.active ? "active" : "inactive"}`,
         `adapters: ${cp.adapters.length > 0 ? cp.adapters.join(", ") : "(none)"}`,
         `routes: ${routeText}`,
-    ].join("\n");
+        generationSummary(cp.generation),
+        observabilitySummary(cp.observability.counters),
+    ];
+    return lines.join("\n");
 }
 function sliceWithLimit(items, limitRaw, fallback = 50) {
     const limit = clampInt(limitRaw, fallback, 1, 200);
@@ -68,7 +85,7 @@ function registerServerTools(pi, opts) {
         ctx.ui.setStatus("mu-server", ctx.ui.theme.fg("dim", `μ server ${url}`));
         try {
             const status = await fetchMuStatus(4_000);
-            ctx.ui.setStatus("mu-status", ctx.ui.theme.fg("dim", `open ${status.open_count} · ready ${status.ready_count} · cp ${status.control_plane?.active ? "on" : "off"}`));
+            ctx.ui.setStatus("mu-status", ctx.ui.theme.fg("dim", `open ${status.open_count} · ready ${status.ready_count} · cp ${status.control_plane.active ? "on" : "off"}`));
         }
         catch {
             ctx.ui.setStatus("mu-status", ctx.ui.theme.fg("warning", "μ status unavailable"));
@@ -96,19 +113,19 @@ function registerServerTools(pi, opts) {
         parameters: ControlPlaneParams,
         async execute(_toolCallId, params) {
             const status = await fetchMuStatus();
-            const cp = status.control_plane ?? {
-                active: false,
-                adapters: [],
-                routes: [],
-            };
+            const cp = status.control_plane;
             const routes = cpRoutesFromStatus(cp.routes, cp.adapters);
+            const generation = cp.generation;
+            const observability = cp.observability.counters;
             switch (params.action) {
                 case "status":
                     return textResult(toJsonText({
                         active: cp.active,
                         adapters: cp.adapters,
                         routes,
-                    }), { control_plane: cp, routes });
+                        generation,
+                        observability,
+                    }), { control_plane: cp, routes, generation, observability });
                 case "adapters":
                     return textResult(toJsonText(cp.adapters), { adapters: cp.adapters });
                 case "routes":
@@ -360,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();
@@ -372,21 +391,21 @@ 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();
-                const cp = status.control_plane ?? {
-                    active: false,
-                    adapters: [],
-                    routes: [],
-                };
+                const cp = status.control_plane;
                 const routes = cpRoutesFromStatus(cp.routes, cp.adapters);
                 const lines = [
                     `control_plane: ${cp.active ? "active" : "inactive"}`,
                     `adapters: ${cp.adapters.length > 0 ? cp.adapters.join(", ") : "(none)"}`,
                     `routes: ${routes.length > 0 ? routes.map((entry) => `${entry.name}:${entry.route}`).join(", ") : "(none)"}`,
+                    generationSummary(cp.generation),
+                    observabilitySummary(cp.observability.counters),
                 ];
                 ctx.ui.notify(lines.join("\n"), "info");
             }
@@ -400,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/dist/extensions/shared.d.ts

@@ -2,15 +2,48 @@ export type MuControlPlaneRoute = {
     name: string;
     route: string;
 };
+export type MuGenerationIdentity = {
+    generation_id: string;
+    generation_seq: number;
+};
+export type MuGenerationReloadAttempt = {
+    attempt_id: string;
+    reason: string;
+    state: "planned" | "swapped" | "completed" | "failed";
+    requested_at_ms: number;
+    swapped_at_ms: number | null;
+    finished_at_ms: number | null;
+    from_generation: MuGenerationIdentity | null;
+    to_generation: MuGenerationIdentity;
+};
+export type MuGenerationSupervisorSnapshot = {
+    supervisor_id: string;
+    active_generation: MuGenerationIdentity | null;
+    pending_reload: MuGenerationReloadAttempt | null;
+    last_reload: MuGenerationReloadAttempt | null;
+};
+export type MuGenerationObservabilityCounters = {
+    reload_success_total: number;
+    reload_failure_total: number;
+    reload_drain_duration_ms_total: number;
+    reload_drain_duration_samples_total: number;
+    duplicate_signal_total: number;
+    drop_signal_total: number;
+};
+export type MuControlPlaneStatus = {
+    active: boolean;
+    adapters: string[];
+    routes?: MuControlPlaneRoute[];
+    generation: MuGenerationSupervisorSnapshot;
+    observability: {
+        counters: MuGenerationObservabilityCounters;
+    };
+};
 export type MuStatusResponse = {
     repo_root: string;
     open_count: number;
     ready_count: number;
-    control_plane?: {
-        active: boolean;
-        adapters: string[];
-        routes?: MuControlPlaneRoute[];
-    };
+    control_plane: MuControlPlaneStatus;
 };
 export declare function muServerUrl(): string | null;
 export declare function clampInt(value: number | undefined, fallback: number, min: number, max: number): number;

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

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/extensions/shared.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,MAAM,CAAC,EAAE,mBAAmB,EAAE,CAAC;KAC/B,CAAC;CACF,CAAC;AAEF,wBAAgB,WAAW,IAAI,MAAM,GAAG,IAAI,CAG3C;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKtG;AAED,wBAAsB,WAAW,CAAC,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAChE,OAAO,CAAC,CAAC,CAAC,CA4BZ;AAED,wBAAsB,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAEjF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;;;;;;EAK7E;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEjD"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/extensions/shared.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,eAAe,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC7C,aAAa,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC/C,cAAc,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACjD,WAAW,EAAE,yBAAyB,GAAG,IAAI,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC/C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,8BAA8B,EAAE,MAAM,CAAC;IACvC,mCAAmC,EAAE,MAAM,CAAC;IAC5C,sBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC/B,UAAU,EAAE,8BAA8B,CAAC;IAC3C,aAAa,EAAE;QACd,QAAQ,EAAE,iCAAiC,CAAC;KAC5C,CAAC;CACF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF,wBAAgB,WAAW,IAAI,MAAM,GAAG,IAAI,CAG3C;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKtG;AAED,wBAAsB,WAAW,CAAC,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAChE,OAAO,CAAC,CAAC,CAAC,CA4BZ;AAiCD,wBAAsB,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAGjF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;;;;;;EAK7E;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEjD"}

package/dist/extensions/shared.js

@@ -39,8 +39,30 @@ export async function fetchMuJson(path, opts = {}) {
         clearTimeout(timeout);
     }
 }
+function ensureGenerationScopedStatus(status) {
+    const controlPlane = status.control_plane;
+    if (!controlPlane || typeof controlPlane !== "object") {
+        throw new Error("mu server /api/status missing control_plane payload (expected generation-scoped contract)");
+    }
+    const controlPlaneRecord = controlPlane;
+    if (!("generation" in controlPlaneRecord) || !controlPlaneRecord.generation) {
+        throw new Error("mu server /api/status missing control_plane.generation (expected generation-scoped contract)");
+    }
+    if (!("observability" in controlPlaneRecord) || !controlPlaneRecord.observability) {
+        throw new Error("mu server /api/status missing control_plane.observability (expected generation-scoped contract)");
+    }
+    const observability = controlPlaneRecord.observability;
+    if (typeof observability !== "object" ||
+        observability == null ||
+        !("counters" in observability) ||
+        !observability.counters) {
+        throw new Error("mu server /api/status missing control_plane.observability.counters (expected generation-scoped contract)");
+    }
+    return status;
+}
 export async function fetchMuStatus(timeoutMs) {
-    return await fetchMuJson("/api/status", { timeoutMs });
+    const status = await fetchMuJson("/api/status", { timeoutMs });
+    return ensureGenerationScopedStatus(status);
 }
 export function textResult(text, details = {}) {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@femtomc/mu-agent",
-	"version": "26.2.55",
+	"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: