@mu-crew/mu 3.2.0 → 3.2.1

package/dist/extension/mu-pi.js

@@ -7,7 +7,7 @@ import {
   readFileSync,
   realpathSync,
   rmSync,
-  statSync
+  statSync as statSync2
 } from "fs";
 import { connect, createServer } from "net";
 import { dirname, join as join2 } from "path";
@@ -39,13 +39,17 @@ var LineDecoder = class {
 
 // extension/delegate.ts
 import { execFile } from "child_process";
-import { existsSync } from "fs";
+import { existsSync, statSync } from "fs";
 import { delimiter, join } from "path";
 import { fileURLToPath } from "url";
 var DELEGATE_TOOL = "mu_delegate";
 var DELEGATE_CANCEL_TOOL = "mu_delegate_cancel";
 var DELEGATE_MESSAGE_TYPE = "mu-delegate";
 var DELEGATE_WORKSTREAM = "scratch";
+var DELEGATE_STATUS_KEY = "mu-delegate";
+function delegateStatus(n) {
+  return n > 0 ? `${n} delegate${n === 1 ? "" : "s"} running` : void 0;
+}
 var DELEGATE_TIMEOUT_S = 3600;
 var W = DELEGATE_WORKSTREAM;
 function delegateEnabled(env = process.env) {
@@ -54,6 +58,13 @@ function delegateEnabled(env = process.env) {
   if (env.MU_MUX || env.HERDR_ENV === "1" || env.TMUX || env.TMUX_PANE) return true;
   return onPath("tmux", env) || onPath("herdr", env);
 }
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
 function onPath(bin, env) {
   return (env.PATH ?? "").split(delimiter).some((d) => d !== "" && existsSync(join(d, bin)));
 }
@@ -77,41 +88,71 @@ function defaultRunner() {
     );
   });
 }
-function delegateMessage(name, agent, pane, tail, attach) {
+function formatElapsed(ms) {
+  const t = Math.max(0, Math.round(ms / 1e3));
+  if (t < 60) return `${t}s`;
+  const m = Math.floor(t / 60);
+  if (m < 60) return `${m}m ${String(t % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
+}
+function delegateMessage(name, agent, pane, x = {}) {
+  const timeoutS = x.timeoutS ?? DELEGATE_TIMEOUT_S;
   const who = `Delegate ${W}/${name}`;
+  const took = x.elapsedMs !== void 0 ? ` after ${formatElapsed(x.elapsedMs)}` : "";
   const fate = pane.closed ? "Pane closed." : `Pane kept (${pane.why}).`;
   const look = [
-    attach ? `Attach: ${attach}` : void 0,
+    x.attach ? `Attach: ${x.attach}` : void 0,
     `Read: mu agent read ${name} -n 50 -w ${W}`
-  ].filter((x) => x !== void 0);
-  const tailBlock = tail?.trim() ? `
+  ].filter((v) => v !== void 0);
+  const tailBlock = x.tail?.trim() ? `
 
 Pane tail:
-${tail.trimEnd()}` : "";
+${x.tail.trimEnd()}` : "";
+  const ws = x.workspace ? ` Workspace: ${x.workspace}` : "";
   switch (agent?.outcome) {
     case "done":
-      return `${who} finished. ${fate}
+      return `${who} finished${took}. ${fate}${ws}
 
 ${agent.lastText ?? ""}`;
     case "empty":
-      return `${who} finished without a text answer. ${fate}${tailBlock}`;
+      return `${who} finished${took} without a text answer. ${fate}${ws}${tailBlock}`;
     case "died":
-      return `${who} died before answering. ${fate}${tailBlock}`;
+      return `${who} died${took} before answering. ${fate}${ws}${tailBlock}`;
     case "timeout":
     case "pending":
       return [
-        `${who} is still running after ${DELEGATE_TIMEOUT_S}s; stopped waiting. ${fate}`,
+        `${who} is still running after ${timeoutS}s; stopped waiting, so its answer will not arrive here. ${fate}${ws}`,
         ...look,
         `Wait again: mu agent wait ${name} -w ${W} --json`
       ].join("\n");
     default:
-      return `${who}: mu agent wait gave no result. ${fate}${tailBlock}`;
+      return `${who}: mu agent wait gave no result. ${fate}${ws}${tailBlock}`;
   }
 }
+function labelStem(label) {
+  if (typeof label !== "string") return void 0;
+  const stem = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 20).replace(/-+$/, "");
+  return stem || void 0;
+}
 function registerDelegate(pi, run = defaultRunner()) {
   if (!delegateEnabled()) return;
   const inflight = /* @__PURE__ */ new Map();
   const reserved = /* @__PURE__ */ new Set();
+  let ui;
+  const showStatus = () => {
+    try {
+      ui?.setStatus?.(DELEGATE_STATUS_KEY, delegateStatus(inflight.size));
+    } catch {
+    }
+  };
+  const track = (ctx) => {
+    if (ctx?.hasUI !== false && ctx?.ui) ui = ctx.ui;
+  };
+  const forget = (name) => {
+    inflight.delete(name);
+    reserved.delete(name);
+    showStatus();
+  };
   const mu = run;
   const json = (r) => {
     try {
@@ -122,28 +163,39 @@ function registerDelegate(pi, run = defaultRunner()) {
     }
   };
   const failure = (what, r) => new Error(`${what} failed (exit ${r.code}): ${(r.stderr || r.stdout).trim()}`);
-  async function pickName() {
+  async function pickName(stem) {
     const r = await mu(["agent", "list", "-w", W, "--json"]);
     const agents = json(r)?.agents;
     const taken = new Set(
       Array.isArray(agents) ? agents.map((a) => a.name).filter((n) => n) : []
     );
     for (let n = 1; ; n++) {
-      const name = `delegate-${n}`;
+      const name = stem ? n === 1 ? `delegate-${stem}` : `delegate-${stem}-${n}` : `delegate-${n}`;
       if (!taken.has(name) && !reserved.has(name)) {
         reserved.add(name);
         return name;
       }
     }
   }
-  async function spawn(params) {
+  async function spawn(params, cwd, signal) {
+    const stem = labelStem(params.label);
     for (let attempt = 0; ; attempt++) {
-      const name = await pickName();
+      signal?.throwIfAborted();
+      const name = await pickName(stem);
       const args = ["agent", "spawn", name, "-w", W, "--json"];
       if (params.workspace === true) args.push("--workspace");
+      else if (cwd) args.push("--cwd", cwd);
       if (typeof params.cli === "string" && params.cli) args.push("--cli", params.cli);
       const r = await mu(args);
-      if (r.code !== 0 && /already exists/.test(r.stderr) && attempt < 3) continue;
+      if (signal?.aborted && r.code === 0) {
+        reserved.delete(name);
+        await mu(["agent", "close", name, "-w", W]);
+        signal.throwIfAborted();
+      }
+      if (r.code !== 0 && /already exists/.test(r.stderr) && attempt < 3) {
+        reserved.delete(name);
+        continue;
+      }
       if (r.code !== 0) {
         reserved.delete(name);
         throw failure("mu agent spawn", r);
@@ -157,10 +209,15 @@ function registerDelegate(pi, run = defaultRunner()) {
       }
       const steps = Array.isArray(out.nextSteps) ? out.nextSteps : [];
       const attach = steps.map((s) => s).find((s) => s.intent === "Attach the pane")?.command;
-      return { name, ...typeof attach === "string" ? { attach } : {} };
+      const wsPath = out.workspace?.path;
+      return {
+        name,
+        ...typeof attach === "string" ? { attach } : {},
+        ...typeof wsPath === "string" ? { workspace: wsPath } : {}
+      };
     }
   }
-  async function deliver(name, wait, keep, attach) {
+  async function deliver(name, wait, keep, extras) {
     const agent = json(wait)?.agents?.[0];
     const outcome = agent?.outcome;
     const tail = outcome === "done" || outcome === "timeout" || outcome === "pending" ? void 0 : (await mu(["agent", "read", name, "-n", "50", "-w", W])).stdout;
@@ -174,9 +231,17 @@ function registerDelegate(pi, run = defaultRunner()) {
     await pi.sendMessage(
       {
         customType: DELEGATE_MESSAGE_TYPE,
-        content: delegateMessage(name, agent, pane, tail, attach),
+        content: delegateMessage(name, agent, pane, { ...extras, ...tail ? { tail } : {} }),
         display: true,
-        details: { name, workstream: W, outcome: outcome ?? null, closed: pane.closed }
+        details: {
+          name,
+          workstream: W,
+          outcome: outcome ?? null,
+          closed: pane.closed,
+          answer: outcome === "done" ? agent?.lastText ?? null : null,
+          elapsedMs: extras.elapsedMs ?? null,
+          workspace: extras.workspace ?? null
+        }
       },
       { deliverAs: "followUp", triggerTurn: true }
     );
@@ -184,23 +249,36 @@ function registerDelegate(pi, run = defaultRunner()) {
   pi.registerTool({
     name: DELEGATE_TOOL,
     label: "mu delegate",
-    description: `Hand one self-contained task to a fresh pi agent in its own mux pane (mu's ${W} workstream) and keep working. Returns at once; the delegate's final answer arrives later as a follow-up message, so do not wait or poll for it. Use it for independent side work (research, a review, a draft, an investigation) you would otherwise do serially. The delegate starts with no context: put everything it needs in task. Several calls run in parallel. The pane is closed after a clean finish unless keep is true; the user can attach to it meanwhile.`,
-    promptSnippet: "Delegate a self-contained task to a background pi agent; its answer arrives later",
+    description: `Subagent: run one self-contained task in a fresh pi agent (its own mux pane in mu's ${W} workstream) while you keep working. Use it whenever you would reach for a subagent: research, a review, a draft, an investigation; call it several times to fan out in parallel. The subagent starts with no context, in your working directory: put everything it needs in task. The call returns at once and the answer arrives later as a follow-up message: carry on with other work, or end your turn if your next step needs the answer (the follow-up resumes you). The pane closes after a clean finish; keep: true leaves it open.`,
+    promptSnippet: "Subagent: delegate a self-contained task to a background pi agent; its answer arrives later as a follow-up",
     parameters: {
       type: "object",
       properties: {
         task: { type: "string", description: "The complete task, with all context it needs" },
+        label: {
+          type: "string",
+          description: "Short label naming the delegate, e.g. 'review' \u2192 delegate-review. Use one per subtask when fanning out."
+        },
         brief: {
           type: "string",
-          description: "Optional persona or ground rules, sent before the task"
+          description: "Optional standing role or rules, sent before the task, e.g. 'You are a reviewer; read only.' The rules are instructions, not enforced. The job itself goes in task."
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory for the delegate (default: yours; ignored with workspace)"
+        },
+        timeout: {
+          type: "number",
+          exclusiveMinimum: 0,
+          description: `Seconds to wait for the answer (default ${DELEGATE_TIMEOUT_S}). On timeout you get a "still running" follow-up instead of the answer, and the answer will not arrive later; the subagent keeps running in its pane.`
         },
         workspace: {
           type: "boolean",
-          description: "Give it its own VCS workspace (for tasks that edit files)"
+          description: "For tasks that edit files: its own VCS checkout (jj workspace / git worktree / sl share) branched from the current commit. The result and follow-up name the path; changes stay there until you merge them. This isolates repository edits only: the subagent runs as you, with your files, environment and network."
         },
         cli: {
           type: "string",
-          description: "Agent CLI key; resolves $MU_<CLI>_COMMAND (default pi)"
+          description: "Agent CLI key (default pi). Name a configured key such as 'pi_fast' to run a cheaper model."
         },
         keep: {
           type: "boolean",
@@ -210,16 +288,30 @@ function registerDelegate(pi, run = defaultRunner()) {
       required: ["task"],
       additionalProperties: false
     },
-    async execute(_id, params) {
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      track(ctx);
       const task = typeof params.task === "string" ? params.task.trim() : "";
       if (!task) throw new Error("mu_delegate needs a non-empty task");
       const brief = typeof params.brief === "string" ? params.brief.trim() : "";
       const keep = params.keep === true;
-      const { name, attach } = await spawn(params);
-      const entry = { abort: new AbortController(), cancelled: false };
+      const t = params.timeout;
+      if (t !== void 0 && !(typeof t === "number" && Number.isFinite(t) && t > 0))
+        throw new Error(
+          `mu_delegate: timeout must be a positive number of seconds (got ${JSON.stringify(t)})`
+        );
+      const timeoutS = typeof t === "number" ? Math.ceil(t) : DELEGATE_TIMEOUT_S;
+      let cwd;
+      if (params.workspace !== true) {
+        cwd = typeof params.cwd === "string" && params.cwd ? params.cwd : ctx?.cwd ?? process.cwd();
+        if (!isDir(cwd)) throw new Error(`mu_delegate: cwd ${cwd} is not a directory`);
+      }
+      const { name, attach, workspace } = await spawn(params, cwd, signal);
+      const entry = { abort: new AbortController(), cancelling: false };
       inflight.set(name, entry);
+      showStatus();
+      const started = Date.now();
       const waiting = mu(
-        ["agent", "wait", name, "-w", W, "--json", "--timeout", String(DELEGATE_TIMEOUT_S)],
+        ["agent", "wait", name, "-w", W, "--json", "--timeout", String(timeoutS)],
         entry.abort.signal
       );
       const sent = await mu(["agent", "send", name, brief ? `${brief}
@@ -227,23 +319,55 @@ function registerDelegate(pi, run = defaultRunner()) {
 ${task}` : task, "-w", W]);
       if (sent.code !== 0) {
         entry.abort.abort();
-        inflight.delete(name);
-        throw failure(`mu agent send to ${W}/${name}`, sent);
+        forget(name);
+        const c = await mu(["agent", "close", name, "-w", W]);
+        const pane = c.code === 0 ? "Pane closed." : `Pane kept; close it with: mu agent close ${name} -w ${W}`;
+        throw new Error(`${failure(`mu agent send to ${W}/${name}`, sent).message}. ${pane}`);
       }
+      const settle = async (r) => {
+        forget(name);
+        try {
+          await deliver(name, r, keep, {
+            timeoutS,
+            elapsedMs: Date.now() - started,
+            ...attach ? { attach } : {},
+            ...workspace ? { workspace } : {}
+          });
+        } catch (e) {
+          await Promise.resolve(
+            pi.sendMessage(
+              {
+                customType: DELEGATE_MESSAGE_TYPE,
+                content: `Delegate ${W}/${name} settled, but delivering its answer failed: ${e instanceof Error ? e.message : String(e)}. Read it with: mu agent read ${name} -n 50 -w ${W}`,
+                display: true,
+                details: { name, workstream: W, outcome: null, closed: false }
+              },
+              { deliverAs: "followUp", triggerTurn: true }
+            )
+          ).catch(() => {
+          });
+        }
+      };
       void waiting.then(async (r) => {
-        if (inflight.get(name) !== entry || entry.cancelled) return;
-        inflight.delete(name);
-        reserved.delete(name);
-        await deliver(name, r, keep, attach);
+        if (inflight.get(name) !== entry) return;
+        if (entry.cancelling) entry.parked = () => settle(r);
+        else await settle(r);
       });
       const lines = [
         `Delegated to ${W}/${name}. Its answer arrives as a follow-up message when it finishes; do not wait or poll.`,
+        workspace ? `Workspace: ${workspace}` : void 0,
         attach ? `Attach: ${attach}` : void 0,
         `Cancel: ${DELEGATE_CANCEL_TOOL} { name: "${name}" }`
       ].filter((x) => x !== void 0);
       return {
         content: [{ type: "text", text: lines.join("\n") }],
-        details: { name, workstream: W, attach: attach ?? null, keep }
+        details: {
+          name,
+          workstream: W,
+          attach: attach ?? null,
+          workspace: workspace ?? null,
+          keep
+        }
       };
     }
   });
@@ -260,19 +384,26 @@ ${task}` : task, "-w", W]);
       required: ["name"],
       additionalProperties: false
     },
-    async execute(_id, params) {
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      track(ctx);
       const name = typeof params.name === "string" ? params.name : "";
       if (!name) throw new Error("mu_delegate_cancel needs a name");
       const entry = inflight.get(name);
-      if (entry) entry.cancelled = true;
+      if (entry) entry.cancelling = true;
       const ab = await mu(["agent", "abort", name, "-w", W]);
       if (ab.code !== 0) {
-        if (entry) entry.cancelled = false;
+        if (entry) {
+          entry.cancelling = false;
+          const parked = entry.parked;
+          entry.parked = void 0;
+          if (parked) void parked();
+        }
         throw failure(`mu agent abort ${W}/${name}`, ab);
       }
-      entry?.abort.abort();
-      inflight.delete(name);
-      reserved.delete(name);
+      if (entry) {
+        entry.abort.abort();
+        forget(name);
+      }
       let text = `Aborted ${W}/${name}.`;
       if (params.keep === true) text += " Pane kept.";
       else {
@@ -287,6 +418,8 @@ ${task}` : task, "-w", W]);
     const names = [...inflight.keys()];
     for (const e of inflight.values()) e.abort.abort();
     inflight.clear();
+    showStatus();
+    ui = void 0;
     const msg = `${names.length} delegate${names.length === 1 ? "" : "s"} still running: ${names.join(", ")}. Their answers will not come back here; use mu agent wait <name> -w ${W} --json.`;
     if (ctx?.hasUI && ctx.ui) ctx.ui.notify(msg, "warning");
     else process.stderr.write(`mu: ${msg}
@@ -295,7 +428,7 @@ ${task}` : task, "-w", W]);
 }
 
 // extension/mu-pi.ts
-var EXT_VERSION = true ? "3.2.0" : void 0;
+var EXT_VERSION = true ? "3.2.1" : void 0;
 var FRESH_COMMAND = "mu-fresh";
 var FRESH_TIMEOUT_MS = 3e4;
 var LAST_TEXT_MAX_BYTES = 64 * 1024;
@@ -370,7 +503,7 @@ ${LAST_TEXT_TRUNCATED}`;
 }
 function inodeOf(path) {
   try {
-    return statSync(path).ino;
+    return statSync2(path).ino;
   } catch {
     return void 0;
   }