@femtomc/mu-agent 26.2.88 → 26.2.89

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;AA2fpF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,YAAY,QAydnD;AAED,eAAe,mBAAmB,CAAC"}

package/dist/extensions/planning-ui.js

@@ -6,6 +6,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":
@@ -259,7 +264,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 +274,46 @@ 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", "·")} `));
     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() {

package/package.json

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