@femtomc/mu-agent 26.2.106 → 26.2.107

package/dist/operator.d.ts

@@ -1,4 +1,4 @@
-import { type HudDoc } from "@femtomc/mu-core";
+import { type HudDoc, type UiDoc } from "@femtomc/mu-core";
 import { z } from "zod";
 import { CommandContextResolver } from "./command_context.js";
 import { type CreateMuSessionOpts, type MuSession } from "./session_factory.js";
@@ -223,6 +223,89 @@ export declare const OperatorBackendTurnResultSchema: z.ZodDiscriminatedUnion<[z
         updated_at_ms: z.ZodNumber;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
+    ui_docs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        v: z.ZodDefault<z.ZodLiteral<1>>;
+        ui_id: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        components: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            id: z.ZodString;
+            text: z.ZodString;
+            tone: z.ZodOptional<z.ZodEnum<{
+                error: "error";
+                info: "info";
+                success: "success";
+                warning: "warning";
+                muted: "muted";
+                accent: "accent";
+                dim: "dim";
+            }>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"list">;
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                detail: z.ZodOptional<z.ZodString>;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    success: "success";
+                    warning: "warning";
+                    muted: "muted";
+                    accent: "accent";
+                    dim: "dim";
+                }>>;
+            }, z.core.$strict>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"key_value">;
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            rows: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    success: "success";
+                    warning: "warning";
+                    muted: "muted";
+                    accent: "accent";
+                    dim: "dim";
+                }>>;
+            }, z.core.$strict>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"divider">;
+            id: z.ZodString;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>], "kind">>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                secondary: "secondary";
+                danger: "danger";
+                link: "link";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            component_id: z.ZodOptional<z.ZodString>;
+            callback_token: z.ZodOptional<z.ZodString>;
+            payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>>;
+        revision: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strict>;
+        updated_at_ms: z.ZodNumber;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"command">;
     command: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -424,6 +507,89 @@ export declare const OperatorBackendTurnResultSchema: z.ZodDiscriminatedUnion<[z
         updated_at_ms: z.ZodNumber;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
+    ui_docs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        v: z.ZodDefault<z.ZodLiteral<1>>;
+        ui_id: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        components: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            id: z.ZodString;
+            text: z.ZodString;
+            tone: z.ZodOptional<z.ZodEnum<{
+                error: "error";
+                info: "info";
+                success: "success";
+                warning: "warning";
+                muted: "muted";
+                accent: "accent";
+                dim: "dim";
+            }>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"list">;
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                detail: z.ZodOptional<z.ZodString>;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    success: "success";
+                    warning: "warning";
+                    muted: "muted";
+                    accent: "accent";
+                    dim: "dim";
+                }>>;
+            }, z.core.$strict>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"key_value">;
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            rows: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    success: "success";
+                    warning: "warning";
+                    muted: "muted";
+                    accent: "accent";
+                    dim: "dim";
+                }>>;
+            }, z.core.$strict>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"divider">;
+            id: z.ZodString;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>], "kind">>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                secondary: "secondary";
+                danger: "danger";
+                link: "link";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            component_id: z.ZodOptional<z.ZodString>;
+            callback_token: z.ZodOptional<z.ZodString>;
+            payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>>;
+        revision: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strict>;
+        updated_at_ms: z.ZodNumber;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
 }, z.core.$strip>], "kind">;
 export type OperatorBackendTurnResult = z.infer<typeof OperatorBackendTurnResultSchema>;
 export type OperatorBackendTurnInput = {
@@ -441,12 +607,14 @@ export type OperatorDecision = {
     kind: "response";
     message: string;
     hud_docs?: HudDoc[];
+    ui_docs?: UiDoc[];
     operatorSessionId: string;
     operatorTurnId: string;
 } | {
     kind: "command";
     commandText: string;
     hud_docs?: HudDoc[];
+    ui_docs?: UiDoc[];
     operatorSessionId: string;
     operatorTurnId: string;
 } | {

package/dist/operator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../src/operator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../src/operator.ts"],"names":[],"mappings":"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"}

package/dist/operator.js

@@ -1,4 +1,4 @@
-import { HudDocSchema, normalizeHudDocs } from "@femtomc/mu-core";
+import { HudDocSchema, UiDocSchema, normalizeHudDocs, normalizeUiDocs, } from "@femtomc/mu-core";
 import { appendJsonl, getStorePaths } from "@femtomc/mu-core/node";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -8,6 +8,7 @@ import { createMuSession } from "./session_factory.js";
 import { DEFAULT_OPERATOR_SYSTEM_PROMPT } from "./default_prompts.js";
 const OPERATOR_RESPONSE_MAX_CHARS = 12_000;
 const OPERATOR_TURN_HUD_DOCS_MAX = 16;
+const OPERATOR_TURN_UI_DOCS_MAX = 16;
 const SAFE_RESPONSE_RE = new RegExp(`^[\\s\\S]{1,${OPERATOR_RESPONSE_MAX_CHARS}}$`);
 const OPERATOR_TIMEOUT_MIN_MS = 1_000;
 const OPERATOR_TIMEOUT_HARD_CAP_MS = 10 * 60 * 1_000;
@@ -45,16 +46,19 @@ export const OperatorApprovedCommandSchema = z.discriminatedUnion("kind", [
     }),
 ]);
 const OperatorTurnHudDocsSchema = z.array(HudDocSchema).max(OPERATOR_TURN_HUD_DOCS_MAX).optional();
+const OperatorTurnUiDocsSchema = z.array(UiDocSchema).max(OPERATOR_TURN_UI_DOCS_MAX).optional();
 export const OperatorBackendTurnResultSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("respond"),
         message: z.string().trim().min(1).max(OPERATOR_RESPONSE_MAX_CHARS),
         hud_docs: OperatorTurnHudDocsSchema,
+        ui_docs: OperatorTurnUiDocsSchema,
     }),
     z.object({
         kind: z.literal("command"),
         command: OperatorApprovedCommandSchema,
         hud_docs: OperatorTurnHudDocsSchema,
+        ui_docs: OperatorTurnUiDocsSchema,
     }),
 ]);
 function normalizeArg(arg) {
@@ -259,6 +263,10 @@ function isHudToolName(toolName) {
     const normalized = toolName.trim().toLowerCase();
     return normalized === "mu_hud";
 }
+function isUiToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    return normalized === "mu_ui";
+}
 function extractHudDocsFromToolResult(result) {
     const rec = asRecord(result);
     if (!rec) {
@@ -278,6 +286,25 @@ function extractHudDocsFromToolResult(result) {
     }
     return normalizeHudDocs(candidates, { maxDocs: OPERATOR_TURN_HUD_DOCS_MAX });
 }
+function extractUiDocsFromToolResult(result) {
+    const rec = asRecord(result);
+    if (!rec) {
+        return [];
+    }
+    const details = asRecord(rec.details);
+    const candidates = [];
+    const topLevelUiDocs = rec.ui_docs;
+    if (Array.isArray(topLevelUiDocs)) {
+        candidates.push(...topLevelUiDocs);
+    }
+    if (details) {
+        const detailUiDocs = details.ui_docs;
+        if (Array.isArray(detailUiDocs)) {
+            candidates.push(...detailUiDocs);
+        }
+    }
+    return normalizeUiDocs(candidates, { maxDocs: OPERATOR_TURN_UI_DOCS_MAX });
+}
 function collectHudDocsFromToolExecutionEvent(event) {
     const rec = asRecord(event);
     if (!rec) {
@@ -292,6 +319,20 @@ function collectHudDocsFromToolExecutionEvent(event) {
     }
     return extractHudDocsFromToolResult(rec.result);
 }
+function collectUiDocsFromToolExecutionEvent(event) {
+    const rec = asRecord(event);
+    if (!rec) {
+        return [];
+    }
+    if (nonEmptyString(rec.type) !== "tool_execution_end") {
+        return [];
+    }
+    const toolName = nonEmptyString(rec.toolName);
+    if (!toolName || !isUiToolName(toolName)) {
+        return [];
+    }
+    return extractUiDocsFromToolResult(rec.result);
+}
 export class JsonFileConversationSessionStore {
     #path;
     #loaded = false;
@@ -500,10 +541,17 @@ export class MessagingOperatorRuntime {
                     operatorTurnId: turnId,
                 };
             }
+            const docPayload = {};
+            if (backendResult.hud_docs && backendResult.hud_docs.length > 0) {
+                docPayload.hud_docs = backendResult.hud_docs;
+            }
+            if (backendResult.ui_docs && backendResult.ui_docs.length > 0) {
+                docPayload.ui_docs = backendResult.ui_docs;
+            }
             return {
                 kind: "response",
                 message,
-                ...(backendResult.hud_docs && backendResult.hud_docs.length > 0 ? { hud_docs: backendResult.hud_docs } : {}),
+                ...docPayload,
                 operatorSessionId: sessionId,
                 operatorTurnId: turnId,
             };
@@ -521,10 +569,17 @@ export class MessagingOperatorRuntime {
                 operatorTurnId: turnId,
             };
         }
+        const docPayload = {};
+        if (backendResult.hud_docs && backendResult.hud_docs.length > 0) {
+            docPayload.hud_docs = backendResult.hud_docs;
+        }
+        if (backendResult.ui_docs && backendResult.ui_docs.length > 0) {
+            docPayload.ui_docs = backendResult.ui_docs;
+        }
         return {
             kind: "command",
             commandText: approved.commandText,
-            ...(backendResult.hud_docs && backendResult.hud_docs.length > 0 ? { hud_docs: backendResult.hud_docs } : {}),
+            ...docPayload,
             operatorSessionId: sessionId,
             operatorTurnId: turnId,
         };
@@ -789,6 +844,7 @@ export class PiMessagingOperatorBackend {
         let assistantText = "";
         let capturedCommand = null;
         let capturedHudDocs = [];
+        let capturedUiDocs = [];
         const unsub = session.subscribe((event) => {
             // Capture assistant text for fallback responses.
             if (event?.type === "message_end" && event?.message?.role === "assistant") {
@@ -823,6 +879,12 @@ export class PiMessagingOperatorBackend {
                     maxDocs: OPERATOR_TURN_HUD_DOCS_MAX,
                 });
             }
+            const uiDocs = collectUiDocsFromToolExecutionEvent(event);
+            if (uiDocs.length > 0) {
+                capturedUiDocs = normalizeUiDocs([...capturedUiDocs, ...uiDocs], {
+                    maxDocs: OPERATOR_TURN_UI_DOCS_MAX,
+                });
+            }
         });
         const promptText = buildOperatorPrompt(input);
         const promptOnce = async () => {
@@ -884,10 +946,14 @@ export class PiMessagingOperatorBackend {
                 command: capturedCommand,
                 messagePreview: assistantText,
             });
+            const docPayload = {};
             if (capturedHudDocs.length > 0) {
-                return { kind: "command", command: capturedCommand, hud_docs: capturedHudDocs };
+                docPayload.hud_docs = capturedHudDocs;
             }
-            return { kind: "command", command: capturedCommand };
+            if (capturedUiDocs.length > 0) {
+                docPayload.ui_docs = capturedUiDocs;
+            }
+            return { kind: "command", command: capturedCommand, ...docPayload };
         }
         // Otherwise treat the assistant text as a plain response.
         const message = assistantText.trim();
@@ -903,10 +969,14 @@ export class PiMessagingOperatorBackend {
             outcome: "respond",
             messagePreview: responseMessage,
         });
+        const docPayload = {};
         if (capturedHudDocs.length > 0) {
-            return { kind: "respond", message: responseMessage, hud_docs: capturedHudDocs };
+            docPayload.hud_docs = capturedHudDocs;
+        }
+        if (capturedUiDocs.length > 0) {
+            docPayload.ui_docs = capturedUiDocs;
         }
-        return { kind: "respond", message: responseMessage };
+        return { kind: "respond", message: responseMessage, ...docPayload };
     }
     dispose() {
         for (const sessionId of [...this.#sessions.keys()]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-agent",
-  "version": "26.2.106",
+  "version": "26.2.107",
   "description": "Shared operator runtime for mu assistant sessions and serve extensions.",
   "keywords": [
     "mu",
@@ -25,7 +25,7 @@
     "themes/**"
   ],
   "dependencies": {
-    "@femtomc/mu-core": "26.2.106",
+    "@femtomc/mu-core": "26.2.107",
     "@mariozechner/pi-agent-core": "^0.54.2",
     "@mariozechner/pi-ai": "^0.54.2",
     "@mariozechner/pi-coding-agent": "^0.54.2",

package/prompts/skills/automation/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: automation
+description: "Meta-skill for durable and wall-clock automation. Routes to heartbeats and crons for recurring execution control."
+---
+
+# automation
+
+Use this meta-skill when the user wants recurring automation, scheduled execution, or scheduler diagnostics.
+
+## Subskills
+
+- `heartbeats` — durable wake-loop programs that run one bounded pass per tick.
+- `crons` — wall-clock scheduling (`at`, `every`, cron expressions) and lifecycle control.
+
+## Selection guide
+
+1. Use `heartbeats` for state-driven wake loops and short recurring supervision.
+2. Use `crons` for explicit wall-clock schedules and calendar-style timing.
+3. Pair automation with `subagents` stack skills (`protocol`, `execution`, etc.) when the workload is issue-DAG driven.
+
+## Common patterns
+
+- **Durable Orchestration**: Create a heartbeat (`heartbeats`) that runs one bounded `execution` pass per tick to supervise a `subagents` DAG over time, keeping the main chat clear.
+- **Scheduled Maintenance / Memory Update**: Set up a cron job (`crons`) to periodically invoke `memory` to rebuild indexes, fetch new docs, or clean up obsolete logs on a schedule.
+- **Continuous Diagnostics**: A heartbeat that periodically tails application logs or runs bounded check scripts locally. If a failure condition is met, the wake loop exits cleanly and notifies the user via the active channel.

package/prompts/skills/{crons → automation/crons}/SKILL.md

@@ -152,10 +152,10 @@ post concise summary, then exit.
 
 For DAG execution workloads, combine with:
 - `planning`
-- `orchestration`
+- `protocol`
 - `control-flow` (when explicit loop/termination policy is required)
 - `model-routing` (when per-issue model/provider/thinking policy is required)
-- `subagents`
+- `execution`
 - `heartbeats` (for short-cadence wake loops)
 
 ## Diagnostics and recovery

package/prompts/skills/{heartbeats → automation/heartbeats}/SKILL.md

@@ -145,10 +145,10 @@ packet mechanics, raw issue-ID lists). Include them only when diagnosing a block
 
 For hierarchical DAG execution, pair this skill with:
 - `planning`
-- `orchestration`
+- `protocol`
 - `control-flow` (when explicit loop/termination policy is required)
 - `model-routing` (when per-issue model/provider/thinking policy is required)
-- `subagents`
+- `execution`
 
 For wall-clock scheduling semantics (`at`, `every`, `cron`), use `crons`.
 

package/prompts/skills/core/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: core
+description: "Meta-skill for core mu operating primitives. Routes to mu, memory, tmux, and code-mode based on task shape."
+---
+
+# core
+
+Use this meta-skill when the user asks for general `mu` operation guidance and you need to pick the correct foundational skill.
+
+## Subskills
+
+- `mu` — default CLI-first operating workflow (inspect, mutate, verify, handoff).
+- `memory` — historical context retrieval, timeline reconstruction, and memory-index maintenance.
+- `tmux` — persistent terminal/session substrate for bounded command execution and fan-out.
+- `code-mode` — tmux-backed REPL loops for iterative execution and context compression.
+
+## Selection guide
+
+1. Start with `mu` for most day-to-day operator work.
+2. Add `memory` when historical context or timeline anchors are required.
+3. Add `tmux` when durable shell state or parallel worker shells are needed.
+4. Add `code-mode` when solving by live execution is cheaper than chat-only reasoning.
+
+## Common patterns
+
+- **Bounded investigation**: Use `mu` commands (`get`, `read`, `health`) to inspect current state, then use `memory` to find "when did this last work?" before attempting a fix.
+- **Context compression**: If a user asks for complex debugging that involves running code and printing huge errors, route to `code-mode`. The agent can spin up a REPL, iterate on a fix offline, and return only the root cause to the chat.
+- **Parallel fan-out**: If a command takes a long time, or needs to run across multiple directories, route to `tmux` to spawn parallel worker shells, keep them running in the background, and periodically read their output.

package/prompts/skills/{code-mode → core/code-mode}/SKILL.md

@@ -112,7 +112,7 @@ tmux new-session -d -s mu-code-sh "bash --noprofile --norc -i"
 ## Integration with other mu skills
 
 - Use with `planning` when a plan step needs exploratory coding.
-- Use with `orchestration`/`subagents` by assigning one tmux session per worker.
+- Use with `protocol`/`execution` by assigning one tmux session per worker.
 - Use with `control-flow` for explicit retry/termination policy around code passes.
 - Use with `heartbeats`/`crons` when bounded code passes should run on schedule.
 

package/prompts/skills/{mu → core/mu}/SKILL.md

@@ -14,6 +14,7 @@ run focused execution loops, and hand off to specialized skills when needed.
 - [CLI capability map](#cli-capability-map)
 - [Default bounded investigation loop](#default-bounded-investigation-loop)
 - [Common mutation and diagnostics patterns](#common-mutation-and-diagnostics-patterns)
+- [Reference `/answer` flow (mu_ui-only)](#reference-answer-flow-mu_ui-only)
 - [Session, serve, and one-shot surfaces](#session-serve-and-one-shot-surfaces)
 - [Durable automation handoff](#durable-automation-handoff)
 - [Evaluation scenarios](#evaluation-scenarios)
@@ -141,6 +142,37 @@ mu store tail cp_operator_turns --limit 20 --pretty
 mu replay <issue-id-or-log-path>
 ```
 
+## Reference `/answer` flow (mu_ui-only)
+
+Use this as the canonical interactive-skill pattern. Keep all behavior in skill logic and
+`mu_ui` documents/events; do not add adapter- or extension-specific branches.
+
+1. Publish the answer prompt as a `UiDoc` via `mu_ui`:
+
+```json
+{
+  "action": "set",
+  "doc": {
+    "v": 1,
+    "ui_id": "ui:answer",
+    "title": "Answer",
+    "components": [{ "kind": "text", "id": "prompt", "text": "Choose an answer", "metadata": {} }],
+    "actions": [
+      { "id": "answer_yes", "label": "Answer yes", "payload": { "choice": "yes" }, "metadata": { "command_text": "/answer yes" } },
+      { "id": "answer_no", "label": "Answer no", "payload": { "choice": "no" }, "metadata": { "command_text": "/answer no" } }
+    ],
+    "revision": { "id": "rev:answer:1", "version": 1 },
+    "updated_at_ms": 1
+  }
+}
+```
+
+2. On `/answer <choice>` input, validate choice, clear/remove `ui:answer` via `mu_ui`, then emit a
+   normal response.
+3. Keep revisions monotonic (`revision.version`) so reconnect/replay keeps the highest revision.
+4. Rely on `metadata.command_text` for cross-surface parity: TUI + messaging channels should route
+   the same `/answer ...` command text.
+
 ## Session, serve, and one-shot surfaces
 
 Primary interactive surface:
@@ -177,10 +209,10 @@ mu cron --help
 ```
 
 When work is multi-step and issue-graph driven, use `planning` to shape the DAG,
-then `hud` for canonical HUD behavior, then `orchestration` to keep DAG
+then `hud` for canonical HUD behavior, then `protocol` to keep DAG
 semantics consistent, then `control-flow` for explicit loop/termination policy,
 then `model-routing` for per-issue provider/model/thinking selection overlays,
-then `subagents` for durable execution.
+then `execution` for durable execution supervision.
 For REPL-driven exploration and context compression, use `code-mode`.
 For persistent terminal sessions and worker fan-out mechanics, use `tmux`.
 For recurring bounded automation loops, use `heartbeats`.
@@ -205,12 +237,12 @@ For wall-clock schedules (one-shot, interval, cron-expression), use `crons`.
 - Historical context retrieval and index maintenance: **`memory`**
 - Planning/decomposition and DAG review: **`planning`**
 - HUD contract/state updates across surfaces: **`hud`**
-- Shared DAG semantics for planning + execution: **`orchestration`**
+- Shared DAG semantics for planning + execution: **`protocol`**
 - Loop/termination policy overlays (review gates, retries, escalation): **`control-flow`**
 - Per-issue model/provider/thinking selection overlays: **`model-routing`**
 - Live REPL execution and context engineering via tmux: **`code-mode`**
 - Persistent tmux session management + worker fan-out primitives: **`tmux`**
-- Durable multi-agent orchestration: **`subagents`**
+- Durable multi-agent orchestration: **`execution`**
 - Recurring bounded automation scheduling: **`heartbeats`**
 - Wall-clock scheduling workflows: **`crons`**
 - Messaging adapter onboarding:

package/prompts/skills/{tmux → core/tmux}/SKILL.md

@@ -131,7 +131,7 @@ Quick diagnostics checklist:
 ## Integration map
 
 - `code-mode`: tmux-backed REPL persistence and context engineering loops
-- `subagents`: tmux fan-out for parallel worker execution
+- `execution`: tmux fan-out for parallel worker execution
 - `heartbeats` / `crons`: schedule bounded passes that dispatch into tmux workers
 
 ## Evaluation scenarios

package/prompts/skills/messaging/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: messaging
+description: "Meta-skill for messaging/channel onboarding. Routes to setup-slack, setup-discord, setup-telegram, and setup-neovim."
+---
+
+# messaging
+
+Use this meta-skill when the user asks to onboard, repair, or verify channel messaging integration.
+
+## Subskills
+
+- `setup-slack` — Slack adapter setup, verification, and identity linking.
+- `setup-discord` — Discord adapter setup, verification, and identity linking.
+- `setup-telegram` — Telegram adapter setup, webhook flow, and identity linking.
+- `setup-neovim` — Neovim (`mu.nvim`) channel setup and identity linking.
+
+## Selection guide
+
+1. Pick the channel-specific setup skill that matches the target adapter.
+2. Run setup in an inspect -> patch config -> reload -> verify loop.
+3. Confirm identities and delivery behavior before declaring completion.
+
+## Common patterns
+
+- **Agent-First Bootstrap**: Rather than asking the user for all details upfront, start the correct `setup-*` skill to investigate the current `mu` config, generate generic adapter secrets locally (if possible), and only ask the user for web-portal-specific secrets (e.g. Discord bot tokens or Slack bot tokens).
+- **Verification Loop**: After rewriting the channel configuration dict, use the `setup-*` pattern to reload the mu controller (`mu cron ...`) and explicitly check the latest service logs or remote test (`/mu health`) to ensure connectivity works before ending the run.
+- **Identity Context Tying**: During adapter onboarding, link the local OS user identity with their remote Slack/Discord/Telegram IDs so that subsequent `mu exec` jobs running offline can accurately ping the user back.