@femtomc/mu-agent 26.2.88 → 26.2.90

package/README.md

@@ -48,8 +48,8 @@ Current stack:
 
 - `brandingExtension` — mu compact header/footer branding + default theme
 - `eventLogExtension` — event tail + watch widget
-- `planningUiExtension` — planning HUD with phase/checklist state plus user-facing communication metadata (`/mu plan ...`)
-- `subagentsUiExtension` — tmux + issue queue HUD with spawn profiles, pause controls, and queue/session health signals (`/mu subagents ...`)
+- `planningUiExtension` — planning mode: compact HUD for next-step/approval flow plus footer-ready incidental status metadata (`/mu plan ...`)
+- `subagentsUiExtension` — subagents mode: compact HUD with activity sentences from issue/forum events plus footer-ready queue/health metadata (`/mu subagents ...`)
 
 Default operator UI theme is `mu-gruvbox-dark`.
 

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

@@ -1 +1 @@
-{"version":3,"file":"branding.d.ts","sourceRoot":"","sources":["../../src/extensions/branding.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAwEpF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,YAAY,QAmOjD;AAED,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"branding.d.ts","sourceRoot":"","sources":["../../src/extensions/branding.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAyEpF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,YAAY,QA8OjD;AAED,eAAe,iBAAiB,CAAC"}

package/dist/extensions/branding.js

@@ -8,6 +8,7 @@
  */
 import { basename } from "node:path";
 import { MU_DEFAULT_THEME_NAME, MU_VERSION } from "../ui_defaults.js";
+import { getActiveHudMode } from "./hud-mode.js";
 import { registerMuSubcommand } from "./mu-command-dispatcher.js";
 import { fetchMuStatus, muServerUrl } from "./shared.js";
 const EMPTY_SNAPSHOT = {
@@ -127,6 +128,16 @@ export function brandingExtension(pi) {
                         const barColor = pct >= 80 ? "warning" : pct >= 60 ? "muted" : "dim";
                         parts.push(theme.fg("muted", "·"), theme.fg(barColor, `ctx ${pct}%`), theme.fg(barColor, contextBar(pct, 10)));
                     }
+                    const activeHudMode = getActiveHudMode();
+                    if (activeHudMode) {
+                        const extensionStatuses = footerData.getExtensionStatuses();
+                        const modeMetaKey = activeHudMode === "planning" ? "mu-planning-meta" : "mu-subagents-meta";
+                        const modeMeta = extensionStatuses.get(modeMetaKey) ?? "";
+                        parts.push(theme.fg("muted", "·"), theme.fg("accent", `hud:${activeHudMode}`));
+                        if (modeMeta.length > 0) {
+                            parts.push(theme.fg("muted", "·"), theme.fg("dim", truncateToWidth(modeMeta, 42)));
+                        }
+                    }
                     if (snapshot.openCount > 0 || snapshot.readyCount > 0) {
                         parts.push(theme.fg("muted", "·"), theme.fg("dim", `open ${snapshot.openCount} ready ${snapshot.readyCount}`));
                     }

package/dist/extensions/hud-mode.d.ts

@@ -0,0 +1,8 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+export type MuHudMode = "planning" | "subagents";
+export declare function getActiveHudMode(): MuHudMode | null;
+export declare function resetHudMode(): void;
+export declare function setActiveHudMode(mode: MuHudMode | null): void;
+export declare function clearHudMode(mode: MuHudMode): void;
+export declare function syncHudModeStatus(ctx: ExtensionContext): void;
+//# sourceMappingURL=hud-mode.d.ts.map

package/dist/extensions/hud-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hud-mode.d.ts","sourceRoot":"","sources":["../../src/extensions/hud-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,WAAW,CAAC;AAIjD,wBAAgB,gBAAgB,IAAI,SAAS,GAAG,IAAI,CAEnD;AAED,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAE7D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAIlD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAK7D"}

package/dist/extensions/hud-mode.js

@@ -0,0 +1,21 @@
+let activeHudMode = null;
+export function getActiveHudMode() {
+    return activeHudMode;
+}
+export function resetHudMode() {
+    activeHudMode = null;
+}
+export function setActiveHudMode(mode) {
+    activeHudMode = mode;
+}
+export function clearHudMode(mode) {
+    if (activeHudMode === mode) {
+        activeHudMode = null;
+    }
+}
+export function syncHudModeStatus(ctx) {
+    if (!ctx.hasUI) {
+        return;
+    }
+    ctx.ui.setStatus("mu-hud-mode", activeHudMode ? `hud:${activeHudMode}` : undefined);
+}

package/dist/extensions/planning-ui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planning-ui.d.ts","sourceRoot":"","sources":["../../src/extensions/planning-ui.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAmepF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,YAAY,QAydnD;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"planning-ui.d.ts","sourceRoot":"","sources":["../../src/extensions/planning-ui.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAigBpF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,YAAY,QAuenD;AAED,eAAe,mBAAmB,CAAC"}

package/dist/extensions/planning-ui.js

@@ -1,3 +1,4 @@
+import { clearHudMode, setActiveHudMode, syncHudModeStatus } from "./hud-mode.js";
 import { registerMuSubcommand } from "./mu-command-dispatcher.js";
 const DEFAULT_STEPS = [
     "Investigate relevant code/docs/state",
@@ -6,6 +7,11 @@ const DEFAULT_STEPS = [
     "Refine with user feedback until approved",
 ];
 const BAR_CHARS = ["░", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
+const WIDGET_STEP_LIMIT = 4;
+const WIDGET_STEP_LABEL_MAX = 60;
+const WIDGET_ROOT_MAX = 20;
+const WIDGET_NEXT_MAX = 56;
+const WIDGET_BLOCKER_MAX = 56;
 function phaseTone(phase) {
     switch (phase) {
         case "investigating":
@@ -247,6 +253,7 @@ function renderPlanningUi(ctx, state) {
     }
     if (!state.enabled) {
         ctx.ui.setStatus("mu-planning", undefined);
+        ctx.ui.setStatus("mu-planning-meta", undefined);
         ctx.ui.setWidget("mu-planning", undefined);
         return;
     }
@@ -259,7 +266,9 @@ function renderPlanningUi(ctx, state) {
     const meter = progressBar(done, total, 10);
     const waitingLabel = state.waitingOnUser ? "yes" : "no";
     const waitingColor = state.waitingOnUser ? "warning" : "dim";
-    const blockerLabel = shortLabel(state.blocker, "(none)", 56);
+    const rootCompact = shortLabel(rootLabel, "(unset)", WIDGET_ROOT_MAX);
+    const nextCompact = shortLabel(state.nextAction, "(unset)", WIDGET_NEXT_MAX);
+    const blockerCompact = shortLabel(state.blocker, "(none)", WIDGET_BLOCKER_MAX);
     const blockerColor = state.blocker ? "warning" : "dim";
     ctx.ui.setStatus("mu-planning", [
         ctx.ui.theme.fg("dim", "plan"),
@@ -267,31 +276,47 @@ function renderPlanningUi(ctx, state) {
         ctx.ui.theme.fg("dim", `${done}/${total}`),
         ctx.ui.theme.fg(phaseColor, meter),
         ctx.ui.theme.fg(waitingColor, `wait:${waitingLabel}`),
-        ctx.ui.theme.fg("muted", `root:${rootLabel}`),
+        ctx.ui.theme.fg("muted", `root:${rootCompact}`),
     ].join(` ${ctx.ui.theme.fg("muted", "·")} `));
+    ctx.ui.setStatus("mu-planning-meta", `phase:${phase} steps:${done}/${total} wait:${waitingLabel} conf:${state.confidence}`);
     const lines = [
-        ctx.ui.theme.fg("accent", ctx.ui.theme.bold("Planning board")),
-        `  ${ctx.ui.theme.fg("muted", "phase:")} ${ctx.ui.theme.fg(phaseColor, phase)}`,
-        `  ${ctx.ui.theme.fg("muted", "progress:")} ${ctx.ui.theme.fg("dim", `${done}/${total}`)} ${ctx.ui.theme.fg(phaseColor, meter)}`,
-        `  ${ctx.ui.theme.fg("muted", "root:")} ${ctx.ui.theme.fg("dim", rootLabel)}`,
-        `  ${ctx.ui.theme.fg("muted", "waiting_on_user:")} ${ctx.ui.theme.fg(waitingColor, waitingLabel)}`,
-        `  ${ctx.ui.theme.fg("muted", "confidence:")} ${ctx.ui.theme.fg(confidenceColor, state.confidence)}`,
-        `  ${ctx.ui.theme.fg("muted", "next_action:")} ${ctx.ui.theme.fg("dim", shortLabel(state.nextAction, "(unset)", 72))}`,
-        `  ${ctx.ui.theme.fg("muted", "blocker:")} ${ctx.ui.theme.fg(blockerColor, blockerLabel)}`,
-        `  ${ctx.ui.theme.fg("dim", "────────────────────────────")}`,
+        [
+            ctx.ui.theme.fg("accent", ctx.ui.theme.bold("Planning")),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg(phaseColor, phase),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg("dim", `${done}/${total}`),
+            ctx.ui.theme.fg(phaseColor, meter),
+        ].join(" "),
+        [
+            ctx.ui.theme.fg("muted", `root:${rootCompact}`),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg(waitingColor, `wait:${waitingLabel}`),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg(confidenceColor, `conf:${state.confidence}`),
+        ].join(" "),
+        `${ctx.ui.theme.fg("muted", "next:")} ${ctx.ui.theme.fg("dim", nextCompact)}`,
     ];
+    if (state.blocker) {
+        lines.push(`${ctx.ui.theme.fg("muted", "blocker:")} ${ctx.ui.theme.fg(blockerColor, blockerCompact)}`);
+    }
+    lines.push(ctx.ui.theme.fg("dim", "────────────────────────────"));
     if (state.steps.length === 0) {
-        lines.push(ctx.ui.theme.fg("muted", "  (no checklist steps configured)"));
+        lines.push(ctx.ui.theme.fg("muted", "(no checklist steps configured)"));
     }
     else {
-        for (let index = 0; index < state.steps.length; index += 1) {
-            const step = state.steps[index];
+        const shownSteps = state.steps.slice(0, WIDGET_STEP_LIMIT);
+        for (let index = 0; index < shownSteps.length; index += 1) {
+            const step = shownSteps[index];
             const mark = step.done ? ctx.ui.theme.fg("success", "☑") : ctx.ui.theme.fg("muted", "☐");
-            const label = step.done ? ctx.ui.theme.fg("dim", step.label) : ctx.ui.theme.fg("text", step.label);
+            const labelText = shortLabel(step.label, "(empty)", WIDGET_STEP_LABEL_MAX);
+            const label = step.done ? ctx.ui.theme.fg("dim", labelText) : ctx.ui.theme.fg("text", labelText);
             lines.push(`${mark} ${ctx.ui.theme.fg("muted", `${index + 1}.`)} ${label}`);
         }
+        if (state.steps.length > shownSteps.length) {
+            lines.push(ctx.ui.theme.fg("muted", `... +${state.steps.length - shownSteps.length} more steps`));
+        }
     }
-    lines.push(ctx.ui.theme.fg("muted", "  /mu plan status · /mu plan snapshot"));
     ctx.ui.setWidget("mu-planning", lines, { placement: "belowEditor" });
 }
 function planningUsageText() {
@@ -365,6 +390,16 @@ export function planningUiExtension(pi) {
     const refresh = (ctx) => {
         renderPlanningUi(ctx, state);
     };
+    const syncPlanningMode = (ctx, action) => {
+        const passiveAction = action === "status" || action === "snapshot";
+        if (!state.enabled) {
+            clearHudMode("planning");
+        }
+        else if (!passiveAction) {
+            setActiveHudMode("planning");
+        }
+        syncHudModeStatus(ctx);
+    };
     const applyPlanningAction = (params) => {
         switch (params.action) {
             case "status":
@@ -625,9 +660,11 @@ export function planningUiExtension(pi) {
     };
     pi.on("session_start", async (_event, ctx) => {
         refresh(ctx);
+        syncHudModeStatus(ctx);
     });
     pi.on("session_switch", async (_event, ctx) => {
         refresh(ctx);
+        syncHudModeStatus(ctx);
     });
     registerMuSubcommand(pi, {
         subcommand: "plan",
@@ -711,6 +748,7 @@ export function planningUiExtension(pi) {
                 notify(ctx, result.message, result.level ?? "error");
                 return;
             }
+            syncPlanningMode(ctx, params.action);
             ctx.ui.notify(result.message, result.level ?? "info");
         },
     });
@@ -801,6 +839,7 @@ export function planningUiExtension(pi) {
             if (!result.ok) {
                 return planningToolError(result.message);
             }
+            syncPlanningMode(ctx, params.action);
             return {
                 content: [{ type: "text", text: `${result.message}\n\n${planningStatusSummary(state)}` }],
                 details: {

package/dist/extensions/subagents-ui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagents-ui.d.ts","sourceRoot":"","sources":["../../src/extensions/subagents-ui.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AA2uBpF,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,YAAY,QAwmBpD;AAED,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"subagents-ui.d.ts","sourceRoot":"","sources":["../../src/extensions/subagents-ui.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,+BAA+B,CAAC;AAw4BpF,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,YAAY,QAkoBpD;AAED,eAAe,oBAAoB,CAAC"}

package/dist/extensions/subagents-ui.js

@@ -1,3 +1,5 @@
+import { fetchMuJson, muServerUrl } from "./shared.js";
+import { clearHudMode, setActiveHudMode, syncHudModeStatus } from "./hud-mode.js";
 import { registerMuSubcommand } from "./mu-command-dispatcher.js";
 const DEFAULT_PREFIX = "mu-sub-";
 const DEFAULT_ROLE_TAG = "role:worker";
@@ -10,6 +12,12 @@ const MAX_REFRESH_SECONDS = 120;
 const DEFAULT_STALE_AFTER_MS = 60_000;
 const MIN_STALE_SECONDS = 10;
 const MAX_STALE_SECONDS = 3_600;
+const WIDGET_SCOPE_MAX = 52;
+const WIDGET_PREFIX_MAX = 20;
+const WIDGET_SUMMARY_MAX = 76;
+const WIDGET_ERROR_MAX = 72;
+const ACTIVITY_EVENT_LIMIT = 180;
+const ACTIVITY_LINE_LIMIT = 4;
 function shellQuote(value) {
     return `'${value.replaceAll("'", "'\"'\"'")}'`;
 }
@@ -99,6 +107,8 @@ function createDefaultState() {
         staleAfterMs: DEFAULT_STALE_AFTER_MS,
         spawnPaused: false,
         spawnMode: DEFAULT_SPAWN_MODE,
+        activityLines: [],
+        activityError: null,
     };
 }
 function truncateOneLine(input, maxLen = 68) {
@@ -295,14 +305,6 @@ async function listIssueSlices(rootId, roleTag) {
         error: null,
     };
 }
-function formatIssueLine(ctx, issue, opts = {}) {
-    const marker = opts.marker ?? "•";
-    const tone = opts.tone ?? "accent";
-    const id = ctx.ui.theme.fg("dim", issue.id);
-    const priority = ctx.ui.theme.fg("muted", `p${issue.priority}`);
-    const title = ctx.ui.theme.fg("text", truncateOneLine(issue.title));
-    return `  ${ctx.ui.theme.fg(tone, marker)} ${id} ${priority} ${title}`;
-}
 function queueMeter(value, total, width = 10) {
     if (width <= 0 || total <= 0) {
         return "";
@@ -333,6 +335,127 @@ function isRefreshStale(lastUpdatedMs, staleAfterMs) {
     }
     return Date.now() - lastUpdatedMs > staleAfterMs;
 }
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function issueIdFromEvent(event) {
+    const issueId = typeof event.issue_id === "string" ? event.issue_id.trim() : "";
+    return issueId.length > 0 ? issueId : null;
+}
+function eventAgeLabel(tsMs) {
+    if (typeof tsMs !== "number" || !Number.isFinite(tsMs)) {
+        return "now";
+    }
+    const ageSeconds = Math.max(0, Math.round((Date.now() - tsMs) / 1_000));
+    if (ageSeconds < 60) {
+        return `${ageSeconds}s`;
+    }
+    const mins = Math.floor(ageSeconds / 60);
+    if (mins < 60) {
+        return `${mins}m`;
+    }
+    const hours = Math.floor(mins / 60);
+    return `${hours}h`;
+}
+function renderActivitySentence(event) {
+    const issueId = issueIdFromEvent(event);
+    if (!issueId) {
+        return null;
+    }
+    const eventType = typeof event.type === "string" ? event.type : "";
+    const payload = asRecord(event.payload);
+    if (eventType === "forum.post") {
+        const message = asRecord(payload?.message);
+        const body = typeof message?.body === "string" ? message.body.trim() : "";
+        const author = typeof message?.author === "string" ? message.author.trim() : "worker";
+        if (body.length === 0) {
+            return null;
+        }
+        return {
+            issueId,
+            sentence: `${issueId} ${author}: ${truncateOneLine(body, 54)}`,
+        };
+    }
+    if (eventType === "issue.claim") {
+        const ok = payload?.ok === true;
+        if (ok) {
+            return { issueId, sentence: `${issueId} claimed and started work` };
+        }
+        const reason = typeof payload?.reason === "string" ? payload.reason : "claim failed";
+        return { issueId, sentence: `${issueId} claim failed (${truncateOneLine(reason, 36)})` };
+    }
+    if (eventType === "issue.close") {
+        const outcome = typeof payload?.outcome === "string" ? payload.outcome : "closed";
+        return { issueId, sentence: `${issueId} closed (${outcome})` };
+    }
+    if (eventType === "issue.update") {
+        const changed = asRecord(payload?.changed);
+        const changedKeys = changed ? Object.keys(changed) : [];
+        if (changedKeys.includes("status")) {
+            const statusChange = asRecord(changed?.status);
+            const from = typeof statusChange?.from === "string" ? statusChange.from : "?";
+            const to = typeof statusChange?.to === "string" ? statusChange.to : "?";
+            return { issueId, sentence: `${issueId} status ${from} → ${to}` };
+        }
+        if (changedKeys.length > 0) {
+            return {
+                issueId,
+                sentence: `${issueId} updated ${truncateOneLine(changedKeys.join(","), 28)}`,
+            };
+        }
+    }
+    if (eventType === "issue.open") {
+        return { issueId, sentence: `${issueId} reopened` };
+    }
+    return null;
+}
+async function fetchRecentActivity(opts) {
+    if (!muServerUrl()) {
+        return { lines: [], error: null };
+    }
+    let events;
+    try {
+        events = await fetchMuJson(`/api/control-plane/events?limit=${ACTIVITY_EVENT_LIMIT}`, {
+            timeoutMs: 4_000,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { lines: [], error: `activity refresh failed: ${truncateOneLine(message, 60)}` };
+    }
+    if (!Array.isArray(events) || events.length === 0) {
+        return { lines: [], error: null };
+    }
+    const tracked = new Set(opts.issueIds.map((issueId) => issueId.trim()).filter((issueId) => issueId.length > 0));
+    const seenIssueIds = new Set();
+    const lines = [];
+    const sorted = [...events].sort((left, right) => {
+        const leftTs = typeof left.ts_ms === "number" ? left.ts_ms : 0;
+        const rightTs = typeof right.ts_ms === "number" ? right.ts_ms : 0;
+        return rightTs - leftTs;
+    });
+    for (const event of sorted) {
+        const rendered = renderActivitySentence(event);
+        if (!rendered) {
+            continue;
+        }
+        if (tracked.size > 0 && !tracked.has(rendered.issueId)) {
+            continue;
+        }
+        if (seenIssueIds.has(rendered.issueId)) {
+            continue;
+        }
+        seenIssueIds.add(rendered.issueId);
+        lines.push(`${eventAgeLabel(event.ts_ms)} ${rendered.sentence}`);
+        if (lines.length >= ACTIVITY_LINE_LIMIT) {
+            break;
+        }
+    }
+    return { lines, error: null };
+}
 function computeQueueDrift(sessions, activeIssues) {
     const activeWithoutSessionIds = activeIssues
         .filter((issue) => !issueHasSession(sessions, issue.id))
@@ -406,6 +529,7 @@ function subagentsSnapshot(state, format) {
             `spawn_paused: ${paused}`,
             `queues: ${state.readyIssues.length} ready / ${state.activeIssues.length} active`,
             `sessions: ${state.sessions.length}`,
+            `activity_lines: ${state.activityLines.length}`,
             `drift_active_without_session: ${drift.activeWithoutSessionIds.length}`,
             `drift_orphan_sessions: ${drift.orphanSessions.length}`,
             `refresh_age: ${refreshAge}`,
@@ -425,6 +549,7 @@ function subagentsSnapshot(state, format) {
         `active=${state.activeIssues.length}`,
         `sessions=${state.sessions.length}`,
         `drift=${staleCount}`,
+        `activity=${state.activityLines.length}`,
         `refresh=${refreshAge}`,
     ].join(" · ");
 }
@@ -434,11 +559,14 @@ function renderSubagentsUi(ctx, state) {
     }
     if (!state.enabled) {
         ctx.ui.setStatus("mu-subagents", undefined);
+        ctx.ui.setStatus("mu-subagents-meta", undefined);
         ctx.ui.setWidget("mu-subagents", undefined);
         return;
     }
     const issueScope = state.issueRootId ? `root:${state.issueRootId}` : "all-roots";
     const roleScope = state.issueRoleTag ? state.issueRoleTag : "(all roles)";
+    const scopeCompact = truncateOneLine(`${issueScope} · ${roleScope}`, WIDGET_SCOPE_MAX);
+    const prefixCompact = truncateOneLine(state.prefix || "(all sessions)", WIDGET_PREFIX_MAX);
     const refreshStale = isRefreshStale(state.lastUpdatedMs, state.staleAfterMs);
     const drift = computeQueueDrift(state.sessions, state.activeIssues);
     const staleCount = drift.activeWithoutSessionIds.length + drift.orphanSessions.length;
@@ -452,82 +580,84 @@ function renderSubagentsUi(ctx, state) {
     const pausedColor = state.spawnPaused ? "warning" : "dim";
     const refreshSeconds = Math.round(state.refreshIntervalMs / 1_000);
     const staleAfterSeconds = Math.round(state.staleAfterMs / 1_000);
+    const activityLines = state.activityLines.slice(0, ACTIVITY_LINE_LIMIT);
     ctx.ui.setStatus("mu-subagents", [
         ctx.ui.theme.fg("dim", "subagents"),
         ctx.ui.theme.fg(healthColor, healthLabel),
-        ctx.ui.theme.fg("dim", `${state.spawnMode}`),
+        ctx.ui.theme.fg("dim", `mode:${state.spawnMode}`),
         ctx.ui.theme.fg(pausedColor, `paused:${pausedLabel}`),
-        ctx.ui.theme.fg("dim", `${state.sessions.length} tmux`),
-        ctx.ui.theme.fg("dim", `${state.readyIssues.length} ready/${state.activeIssues.length} active`),
-        ctx.ui.theme.fg("muted", issueScope),
+        ctx.ui.theme.fg("dim", `q:${state.readyIssues.length}/${state.activeIssues.length}`),
+        ctx.ui.theme.fg("dim", `tmux:${state.sessions.length}`),
+        ctx.ui.theme.fg(staleCount > 0 ? "warning" : "dim", `drift:${staleCount}`),
+        ctx.ui.theme.fg("muted", truncateOneLine(issueScope, 18)),
     ].join(` ${ctx.ui.theme.fg("muted", "·")} `));
+    ctx.ui.setStatus("mu-subagents-meta", `health:${healthLabel} q:${state.readyIssues.length}/${state.activeIssues.length} tmux:${state.sessions.length} drift:${staleCount} refresh:${refreshAge}`);
     const lines = [
-        ctx.ui.theme.fg("accent", ctx.ui.theme.bold("Subagents board")),
-        `  ${ctx.ui.theme.fg("muted", "health:")} ${ctx.ui.theme.fg(healthColor, healthLabel)}`,
-        `  ${ctx.ui.theme.fg("muted", "scope:")} ${ctx.ui.theme.fg("dim", `${issueScope} · ${roleScope}`)}`,
-        `  ${ctx.ui.theme.fg("muted", "tmux prefix:")} ${ctx.ui.theme.fg("dim", state.prefix || "(all sessions)")}`,
-        `  ${ctx.ui.theme.fg("muted", "spawn mode:")} ${ctx.ui.theme.fg("accent", state.spawnMode)}`,
-        `  ${ctx.ui.theme.fg("muted", "spawn paused:")} ${ctx.ui.theme.fg(pausedColor, pausedLabel)}`,
-        `  ${ctx.ui.theme.fg("muted", "refresh:")} ${ctx.ui.theme.fg("dim", `${refreshSeconds}s`)} ${ctx.ui.theme.fg("muted", "| stale after:")} ${ctx.ui.theme.fg("dim", `${staleAfterSeconds}s`)}`,
-        `  ${ctx.ui.theme.fg("muted", "queues:")} ${ctx.ui.theme.fg("accent", `${state.readyIssues.length} ready`)} ${ctx.ui.theme.fg("muted", "| ")} ${ctx.ui.theme.fg("warning", `${state.activeIssues.length} active`)} ${ctx.ui.theme.fg("dim", queueBar)}`,
-        `  ${ctx.ui.theme.fg("muted", "last refresh:")} ${ctx.ui.theme.fg(refreshStale ? "warning" : "dim", refreshAge)}`,
-        `  ${ctx.ui.theme.fg("dim", "────────────────────────────")}`,
-        ctx.ui.theme.fg("accent", `tmux sessions (${state.sessions.length})`),
+        [
+            ctx.ui.theme.fg("accent", ctx.ui.theme.bold("Subagents")),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg(healthColor, healthLabel),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg("accent", `mode:${state.spawnMode}`),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg(pausedColor, `paused:${pausedLabel}`),
+        ].join(" "),
+        `${ctx.ui.theme.fg("muted", "scope:")} ${ctx.ui.theme.fg("dim", scopeCompact)} ${ctx.ui.theme.fg("muted", "· prefix:")} ${ctx.ui.theme.fg("dim", prefixCompact)}`,
+        [
+            ctx.ui.theme.fg("muted", "queues:"),
+            ctx.ui.theme.fg("accent", `${state.readyIssues.length}r`),
+            ctx.ui.theme.fg("muted", "/"),
+            ctx.ui.theme.fg("warning", `${state.activeIssues.length}a`),
+            ctx.ui.theme.fg("dim", queueBar),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg("muted", "tmux:"),
+            ctx.ui.theme.fg("dim", `${state.sessions.length}`),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg(staleCount > 0 ? "warning" : "dim", `drift:${staleCount}`),
+        ].join(" "),
+        [
+            ctx.ui.theme.fg("muted", "refresh:"),
+            ctx.ui.theme.fg(refreshStale ? "warning" : "dim", refreshAge),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg("muted", "every:"),
+            ctx.ui.theme.fg("dim", `${refreshSeconds}s`),
+            ctx.ui.theme.fg("muted", "·"),
+            ctx.ui.theme.fg("muted", "stale:"),
+            ctx.ui.theme.fg("dim", `${staleAfterSeconds}s`),
+        ].join(" "),
     ];
+    if (state.issueError) {
+        lines.push(ctx.ui.theme.fg("warning", `issue_error: ${truncateOneLine(state.issueError, WIDGET_ERROR_MAX)}`));
+    }
     if (state.sessionError) {
-        lines.push(ctx.ui.theme.fg("warning", `  tmux error: ${state.sessionError}`));
+        lines.push(ctx.ui.theme.fg("warning", `tmux_error: ${truncateOneLine(state.sessionError, WIDGET_ERROR_MAX)}`));
     }
-    else if (state.sessions.length === 0) {
-        lines.push(ctx.ui.theme.fg("muted", "  (no matching sessions)"));
+    if (refreshStale) {
+        lines.push(ctx.ui.theme.fg("warning", `warning: refresh stale (>${staleAfterSeconds}s since last successful refresh)`));
     }
-    else {
-        for (const name of state.sessions.slice(0, 8)) {
-            lines.push(`  ${ctx.ui.theme.fg("success", "●")} ${ctx.ui.theme.fg("text", name)}`);
-        }
-        if (state.sessions.length > 8) {
-            lines.push(ctx.ui.theme.fg("muted", `  ... +${state.sessions.length - 8} more tmux sessions`));
-        }
+    if (drift.activeWithoutSessionIds.length > 0) {
+        lines.push(ctx.ui.theme.fg("warning", truncateOneLine(`drift_missing: ${drift.activeWithoutSessionIds.slice(0, 4).join(", ")}${drift.activeWithoutSessionIds.length > 4 ? " ..." : ""}`, WIDGET_ERROR_MAX)));
     }
-    lines.push(`  ${ctx.ui.theme.fg("dim", "────────────────────────────")}`);
-    if (state.issueError) {
-        lines.push(ctx.ui.theme.fg("warning", `issue error: ${state.issueError}`));
+    if (drift.orphanSessions.length > 0) {
+        lines.push(ctx.ui.theme.fg("warning", truncateOneLine(`drift_orphan: ${drift.orphanSessions.slice(0, 4).join(", ")}${drift.orphanSessions.length > 4 ? " ..." : ""}`, WIDGET_ERROR_MAX)));
     }
-    else {
-        lines.push(ctx.ui.theme.fg("accent", `ready queue (${state.readyIssues.length})`));
-        if (state.readyIssues.length === 0) {
-            lines.push(ctx.ui.theme.fg("muted", "  (no ready issues)"));
-        }
-        else {
-            for (const issue of state.readyIssues.slice(0, 6)) {
-                lines.push(formatIssueLine(ctx, issue, { marker: "→", tone: "accent" }));
-            }
-            if (state.readyIssues.length > 6) {
-                lines.push(ctx.ui.theme.fg("muted", `  ... +${state.readyIssues.length - 6} more ready issues`));
-            }
-        }
-        lines.push(ctx.ui.theme.fg("accent", `active queue (${state.activeIssues.length})`));
-        if (state.activeIssues.length === 0) {
-            lines.push(ctx.ui.theme.fg("muted", "  (no in-progress issues)"));
+    lines.push(ctx.ui.theme.fg("dim", "────────────────────────────"));
+    lines.push(ctx.ui.theme.fg("accent", "activity"));
+    if (state.activityError) {
+        lines.push(ctx.ui.theme.fg("warning", truncateOneLine(state.activityError, WIDGET_ERROR_MAX)));
+    }
+    else if (activityLines.length === 0) {
+        if (state.activeIssues.length > 0) {
+            lines.push(ctx.ui.theme.fg("muted", "(no recent subagent updates yet)"));
         }
         else {
-            for (const issue of state.activeIssues.slice(0, 6)) {
-                lines.push(formatIssueLine(ctx, issue, { marker: "●", tone: "warning" }));
-            }
-            if (state.activeIssues.length > 6) {
-                lines.push(ctx.ui.theme.fg("muted", `  ... +${state.activeIssues.length - 6} more active issues`));
-            }
+            lines.push(ctx.ui.theme.fg("muted", "(no active workers)"));
         }
     }
-    if (refreshStale) {
-        lines.push(ctx.ui.theme.fg("warning", `refresh warning: last successful refresh is stale (>${staleAfterSeconds}s)`));
-    }
-    if (drift.activeWithoutSessionIds.length > 0) {
-        lines.push(ctx.ui.theme.fg("warning", `drift warning: active issues without tmux sessions (${drift.activeWithoutSessionIds.length})`));
-        lines.push(ctx.ui.theme.fg("warning", `  missing sessions for: ${drift.activeWithoutSessionIds.slice(0, 8).join(", ")}${drift.activeWithoutSessionIds.length > 8 ? " ..." : ""}`));
-    }
-    if (drift.orphanSessions.length > 0) {
-        lines.push(ctx.ui.theme.fg("warning", `drift warning: tmux sessions without active issues (${drift.orphanSessions.length})`));
-        lines.push(ctx.ui.theme.fg("warning", `  orphan sessions: ${drift.orphanSessions.slice(0, 8).join(", ")}${drift.orphanSessions.length > 8 ? " ..." : ""}`));
+    else {
+        for (const line of activityLines) {
+            lines.push(`${ctx.ui.theme.fg("muted", "•")} ${ctx.ui.theme.fg("text", truncateOneLine(line, WIDGET_SUMMARY_MAX))}`);
+        }
     }
     ctx.ui.setWidget("mu-subagents", lines, { placement: "belowEditor" });
 }
@@ -564,6 +694,8 @@ function subagentsDetails(state) {
         refresh_stale: isRefreshStale(state.lastUpdatedMs, state.staleAfterMs),
         issue_error: state.issueError,
         session_error: state.sessionError,
+        activity_lines: [...state.activityLines],
+        activity_error: state.activityError,
         last_updated_ms: state.lastUpdatedMs,
         snapshot_compact: subagentsSnapshot(state, "compact"),
         snapshot_multiline: subagentsSnapshot(state, "multiline"),
@@ -597,6 +729,12 @@ export function subagentsUiExtension(pi) {
         state.readyIssues = issues.ready;
         state.activeIssues = issues.active;
         state.issueError = issues.error;
+        const trackedIssueIds = (state.activeIssues.length > 0 ? state.activeIssues : state.readyIssues)
+            .slice(0, 8)
+            .map((issue) => issue.id);
+        const activity = await fetchRecentActivity({ issueIds: trackedIssueIds });
+        state.activityLines = activity.lines;
+        state.activityError = activity.error;
         state.lastUpdatedMs = Date.now();
         renderSubagentsUi(ctx, state);
     };
@@ -628,6 +766,16 @@ export function subagentsUiExtension(pi) {
     const notify = (ctx, message, level = "info") => {
         ctx.ui.notify(`${message}\n\n${subagentsUsageText()}`, level);
     };
+    const syncSubagentsMode = (ctx, action) => {
+        const passiveAction = action === "status" || action === "snapshot";
+        if (!state.enabled) {
+            clearHudMode("subagents");
+        }
+        else if (!passiveAction) {
+            setActiveHudMode("subagents");
+        }
+        syncHudModeStatus(ctx);
+    };
     const statusSummary = () => {
         const when = state.lastUpdatedMs == null ? "never" : new Date(state.lastUpdatedMs).toLocaleTimeString();
         const status = state.enabled ? "enabled" : "disabled";
@@ -637,6 +785,7 @@ export function subagentsUiExtension(pi) {
         const refreshStale = isRefreshStale(state.lastUpdatedMs, state.staleAfterMs);
         const issueError = state.issueError ? `\nissue_error: ${state.issueError}` : "";
         const tmuxError = state.sessionError ? `\ntmux_error: ${state.sessionError}` : "";
+        const activityError = state.activityError ? `\nactivity_error: ${state.activityError}` : "";
         const driftInfo = drift.activeWithoutSessionIds.length > 0 || drift.orphanSessions.length > 0
             ? `\ndrift_active_without_session: ${drift.activeWithoutSessionIds.length}\ndrift_orphan_sessions: ${drift.orphanSessions.length}`
             : "";
@@ -644,6 +793,7 @@ export function subagentsUiExtension(pi) {
         return {
             level: state.issueError ||
                 state.sessionError ||
+                state.activityError ||
                 refreshStale ||
                 drift.activeWithoutSessionIds.length > 0 ||
                 drift.orphanSessions.length > 0
@@ -661,10 +811,12 @@ export function subagentsUiExtension(pi) {
                 `sessions: ${state.sessions.length}`,
                 `ready_issues: ${state.readyIssues.length}`,
                 `active_issues: ${state.activeIssues.length}`,
+                `activity_updates: ${state.activityLines.length}`,
                 `last refresh: ${when}`,
             ].join("\n") +
                 issueError +
                 tmuxError +
+                activityError +
                 driftInfo +
                 staleInfo,
         };
@@ -984,6 +1136,7 @@ export function subagentsUiExtension(pi) {
             ensurePolling();
         }
         await refresh(ctx);
+        syncHudModeStatus(ctx);
     });
     pi.on("session_switch", async (_event, ctx) => {
         activeCtx = ctx;
@@ -991,6 +1144,7 @@ export function subagentsUiExtension(pi) {
             ensurePolling();
         }
         await refresh(ctx);
+        syncHudModeStatus(ctx);
     });
     pi.on("session_shutdown", async () => {
         stopPolling();
@@ -1072,6 +1226,7 @@ export function subagentsUiExtension(pi) {
                 notify(ctx, result.message, result.level);
                 return;
             }
+            syncSubagentsMode(ctx, params.action);
             ctx.ui.notify(result.message, result.level);
         },
     });
@@ -1127,6 +1282,7 @@ export function subagentsUiExtension(pi) {
             if (!result.ok) {
                 return subagentsToolError(result.message, state);
             }
+            syncSubagentsMode(ctx, params.action);
             return {
                 content: [{ type: "text", text: result.message }],
                 details: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-agent",
-  "version": "26.2.88",
+  "version": "26.2.90",
   "description": "Shared agent runtime for mu assistant sessions, orchestration roles, and serve extensions.",
   "keywords": [
     "mu",
@@ -24,7 +24,7 @@
     "themes/**"
   ],
   "dependencies": {
-    "@femtomc/mu-core": "26.2.88",
+    "@femtomc/mu-core": "26.2.90",
     "@mariozechner/pi-agent-core": "^0.53.0",
     "@mariozechner/pi-ai": "^0.53.0",
     "@mariozechner/pi-coding-agent": "^0.53.0",

package/prompts/skills/planning/SKILL.md

@@ -1,12 +1,27 @@
 ---
 name: planning
-description: Investigate first, then propose a concrete issue plan and refine it with the user until approved.
+description: Investigate first, use the planning HUD as the user-facing status channel, then propose and refine a concrete issue DAG until approved.
 ---
 
 # Planning
 
 Use this skill when the user asks for planning, decomposition, or a staged execution roadmap.
 
+## Planning HUD is required
+
+For this skill, the planning HUD is the primary status/communication surface.
+
+- Keep HUD state in sync with real planning progress.
+- Update HUD before and after each major planning turn.
+- Use `waiting_on_user`, `next_action`, and `blocker` to communicate exactly what the user needs to do.
+- Include a HUD snapshot in user-facing planning updates.
+
+Default per-turn HUD loop:
+
+1. Apply an atomic `update` with current `phase`, `waiting_on_user`, `next_action`, `blocker`, and `confidence`.
+2. Synchronize checklist items and `root_issue_id` with the issue DAG.
+3. Emit `snapshot` (`compact` or `multiline`) and reflect it in your response.
+
 ## Core contract
 
 1. **Investigate first**
@@ -18,11 +33,17 @@ Use this skill when the user asks for planning, decomposition, or a staged execu
    - Encode dependencies so the DAG reflects execution order.
    - Add clear titles, scope, acceptance criteria, and role tags.
 
-3. **Present the plan to the user**
+3. **Drive communication through the planning HUD**
+   - Treat HUD state as the canonical short status line for planning.
+   - Keep `phase`, `waiting_on_user`, `next_action`, `blocker`, and `confidence` current.
+   - Ensure HUD state and your natural-language response never contradict each other.
+
+4. **Present the plan to the user**
    - Summarize goals, sequencing, risks, and tradeoffs.
    - Include issue IDs so the user can reference exact nodes.
+   - Include a HUD snapshot line.
 
-4. **Iterate until user approval**
+5. **Iterate until user approval**
    - Treat user feedback as first-class constraints.
    - Update issues/dependencies and re-present deltas.
    - Do not begin broad execution until the user signals satisfaction.
@@ -38,13 +59,15 @@ mu forum read user:context --limit 50 --pretty
 mu memory search --query "<topic>" --limit 30
 ```
 
-Optional planning HUD (interactive operator session):
+Bootstrap HUD immediately (interactive operator session):
 
 ```text
 /mu plan on
 /mu plan phase investigating
 /mu plan waiting off
 /mu plan confidence medium
+/mu plan next "Investigate constraints and gather evidence"
+/mu plan snapshot
 ```
 
 Tool contract (preferred when tools are available):
@@ -65,13 +88,21 @@ Tool contract (preferred when tools are available):
   - `step_updates`: array of `{index, done?, label?}`
 
 Example tool calls:
-- Atomic update for user handoff:
+- Atomic status update for an investigation turn:
+  - `{"action":"update","phase":"investigating","waiting_on_user":false,"next_action":"Draft root issue and child DAG","blocker":"clear","confidence":"medium"}`
+- Atomic handoff when waiting for approval:
   - `{"action":"update","phase":"waiting_user","waiting_on_user":true,"next_action":"Confirm scope change","blocker":"Need approval","confidence":"low"}`
+- Clear communication fields after user reply:
+  - `{"action":"update","waiting_on_user":false,"blocker":"clear","next_action":"Incorporate feedback and re-draft DAG"}`
 - Customize checklist:
   - `{"action":"set_steps","steps":["Investigate","Draft DAG","Review with user","Finalize"]}`
 - Human-facing status line:
   - `{"action":"snapshot","snapshot_format":"compact"}`
 
+If HUD behavior is unclear, inspect implementation/tests before guessing:
+- `packages/agent/src/extensions/planning-ui.ts`
+- `packages/agent/test/planning_ui_tool.test.ts`
+
 Also inspect repo files directly (read/bash) for implementation constraints.
 
 ### B) Draft DAG in mu-issue
@@ -98,14 +129,16 @@ mu issues ready --root <root-id> --pretty
 - Proposed issue DAG (IDs + titles + ordering)
 - Risks and mitigations
 - Open questions for user approval
+- HUD snapshot (compact line)
 
 ### D) Revision loop
 
 - Apply feedback with `mu issues update` / `mu issues dep` / additional issues.
 - Re-run `mu issues ready --root <root-id> --pretty`.
 - Present a concise diff of what changed and why.
+- Update HUD each turn so phase/waiting/next/blocker/confidence match the latest state.
 
-Optional HUD updates during the loop:
+Required HUD updates during the loop:
 
 ```text
 /mu plan root <root-id>
@@ -117,9 +150,18 @@ Optional HUD updates during the loop:
 /mu plan snapshot
 ```
 
+## Effective HUD usage heuristics
+
+- Prefer `update` for multi-field changes to avoid inconsistent intermediate state.
+- Reserve `waiting_user` for explicit user input/decision waits; use `blocked` for non-user blockers.
+- Keep `next_action` as one concrete action, not a paragraph.
+- Adjust `confidence` as evidence quality changes (`low` when assumptions are unresolved).
+- Customize checklist steps once scope is understood; check them off as milestones complete.
+
 ## Quality bar
 
 - Every issue should be actionable and testable.
 - Keep tasks small enough to complete in one focused pass.
 - Explicitly call out uncertain assumptions for user confirmation.
 - Prefer reversible plans and incremental checkpoints.
+- HUD state must be fresh, accurate, and aligned with user-visible status updates.