@mu-crew/mu 3.2.1 → 3.4.0

package/dist/extension/mu-pi.js

@@ -1,26 +1,30 @@
 // extension/mu-pi.ts
 import {
   chmodSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   linkSync,
   mkdirSync,
-  readFileSync,
+  readdirSync,
+  readFileSync as readFileSync2,
   realpathSync,
   rmSync,
   statSync as statSync2
 } from "fs";
 import { connect, createServer } from "net";
-import { dirname, join as join2 } from "path";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/ctl/protocol.ts
 var CTL_PROTOCOL_VERSION = 1;
+var CTL_COMMANDS = ["new", "reload", "compact"];
 var CTL_OPS = [
   "hello",
   "status",
   "send",
   "wait",
   "abort",
-  "fresh"
+  "fresh",
+  "command"
 ];
 var UNKNOWN_OP_PREFIX = "unknown op: ";
 function encode(msg) {
@@ -51,6 +55,11 @@ function delegateStatus(n) {
   return n > 0 ? `${n} delegate${n === 1 ? "" : "s"} running` : void 0;
 }
 var DELEGATE_TIMEOUT_S = 3600;
+var DELEGATE_MAX_DEFAULT = 16;
+function delegateMax(env = process.env) {
+  const n = Number(env.MU_DELEGATE_MAX);
+  return Number.isInteger(n) && n > 0 ? n : DELEGATE_MAX_DEFAULT;
+}
 var W = DELEGATE_WORKSTREAM;
 function delegateEnabled(env = process.env) {
   if (env.MU_MANAGED_AGENT) return false;
@@ -137,6 +146,7 @@ function labelStem(label) {
 function registerDelegate(pi, run = defaultRunner()) {
   if (!delegateEnabled()) return;
   const inflight = /* @__PURE__ */ new Map();
+  let starting = 0;
   const reserved = /* @__PURE__ */ new Set();
   let ui;
   const showStatus = () => {
@@ -249,7 +259,7 @@ function registerDelegate(pi, run = defaultRunner()) {
   pi.registerTool({
     name: DELEGATE_TOOL,
     label: "mu delegate",
-    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.`,
+    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 (at most ${delegateMax()} in flight). 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",
@@ -292,83 +302,106 @@ function registerDelegate(pi, run = defaultRunner()) {
       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 t = params.timeout;
-      if (t !== void 0 && !(typeof t === "number" && Number.isFinite(t) && t > 0))
+      const max = delegateMax();
+      if (inflight.size + starting >= max)
         throw new Error(
-          `mu_delegate: timeout must be a positive number of seconds (got ${JSON.stringify(t)})`
+          `mu_delegate: ${inflight.size + starting} delegates already running (MU_DELEGATE_MAX=${max}). End your turn; issue the rest as answers arrive (each answer resumes you).`
         );
-      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(timeoutS)],
-        entry.abort.signal
-      );
-      const sent = await mu(["agent", "send", name, brief ? `${brief}
-
-${task}` : task, "-w", W]);
-      if (sent.code !== 0) {
-        entry.abort.abort();
-        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(() => {
-          });
-        }
+      starting++;
+      let slotHeld = true;
+      const freeSlot = () => {
+        if (slotHeld) starting--;
+        slotHeld = false;
       };
-      void waiting.then(async (r) => {
-        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: {
+      try {
+        const brief = typeof params.brief === "string" ? params.brief.trim() : "";
+        const keep = params.keep === true;
+        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);
+        freeSlot();
+        showStatus();
+        const started = Date.now();
+        const waiting = mu(
+          ["agent", "wait", name, "-w", W, "--json", "--timeout", String(timeoutS)],
+          entry.abort.signal
+        );
+        const sent = await mu([
+          "agent",
+          "send",
           name,
-          workstream: W,
-          attach: attach ?? null,
-          workspace: workspace ?? null,
-          keep
+          brief ? `${brief}
+
+${task}` : task,
+          "-w",
+          W
+        ]);
+        if (sent.code !== 0) {
+          entry.abort.abort();
+          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) 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,
+            workspace: workspace ?? null,
+            keep
+          }
+        };
+      } finally {
+        freeSlot();
+      }
     }
   });
   pi.registerTool({
@@ -427,10 +460,143 @@ ${task}` : task, "-w", W]);
   });
 }
 
+// extension/nudge.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
+var NUDGE_MESSAGE_TYPE = "mu-keep-driving";
+var NUDGE_LOG_KIND = "nudge";
+var MARK_START = "<!-- mu:keep-driving -->";
+var MARK_END = "<!-- /mu:keep-driving -->";
+var WAIT_HINT_MAX = 8;
+function nudgeEnabled(env = process.env) {
+  return env.MU_NUDGE !== "0";
+}
+function keepDrivingRule(skillMd) {
+  const i = skillMd.indexOf(MARK_START);
+  const j = skillMd.indexOf(MARK_END);
+  if (i < 0 || j < i) return void 0;
+  const text = skillMd.slice(i + MARK_START.length, j).trim();
+  return text === "" ? void 0 : text;
+}
+function readSkill() {
+  for (const up of ["..", "../.."]) {
+    const p = join2(import.meta.dirname ?? "", up, "skills", "mu", "SKILL.md");
+    if (existsSync2(p)) return readFileSync(p, "utf8");
+  }
+  return void 0;
+}
+function dispatchedWorkstreams(command) {
+  const found = /* @__PURE__ */ new Set();
+  for (const seg of command.split(/&&|\|\||;|\n|\|/)) {
+    const words = seg.trim().split(/\s+/);
+    const at = words.findIndex((w) => w === "mu" || w.endsWith("/mu"));
+    if (at < 0) continue;
+    const [noun, verb] = [words[at + 1], words[at + 2]];
+    const isSendSpawn = noun === "agent" && (verb === "send" || verb === "spawn");
+    const isClaimFor = noun === "task" && verb === "claim" && words.includes("--for");
+    if (!isSendSpawn && !isClaimFor) continue;
+    let ws = "";
+    for (let k = at + 3; k < words.length; k++) {
+      const w = words[k] ?? "";
+      if (w === "-w" || w === "--workstream") ws = unquote(words[k + 1] ?? "");
+      else if (w.startsWith("--workstream=")) ws = unquote(w.slice("--workstream=".length));
+    }
+    if (ws === "" && isClaimFor) {
+      const ref = words[at + 3] ?? "";
+      if (ref.includes("/")) ws = unquote(ref.split("/")[0] ?? "");
+    }
+    if (ws !== "scratch") found.add(ws);
+  }
+  return found.size > 0 ? [...found] : void 0;
+}
+function unquote(s) {
+  return s.replace(/^['"]|['"]$/g, "");
+}
+async function inProgress(run, workstreams) {
+  const named = workstreams.filter((w) => w !== "");
+  const args = ["state", "--json", "--events", "0"];
+  for (const w of named) args.push("-w", w);
+  const r = await run(args);
+  if (r.code !== 0) return void 0;
+  let json;
+  try {
+    json = JSON.parse(r.stdout);
+  } catch {
+    return void 0;
+  }
+  const cards = json.workstreams ?? [json];
+  const refs = [];
+  for (const ws of cards) {
+    for (const t of ws.inProgress ?? []) {
+      if (t.name) refs.push(`${ws.workstreamName ?? ""}/${t.name}`);
+    }
+  }
+  return refs;
+}
+function nudgeText(rule, refs) {
+  const shown = refs.slice(0, WAIT_HINT_MAX).join(" ");
+  const more = refs.length > WAIT_HINT_MAX ? ` (+${refs.length - WAIT_HINT_MAX} more)` : "";
+  return [
+    `[mu] ${rule}`,
+    "",
+    `${refs.length} task(s) IN_PROGRESS. Next: mu task wait ${shown} --first --on-stall exit --json${more}`
+  ].join("\n");
+}
+function outcomeOf(event) {
+  return typeof event === "object" && event !== null ? event.outcome : void 0;
+}
+function bashCommand(event) {
+  if (typeof event !== "object" || event === null) return void 0;
+  const e = event;
+  return e.toolName === "bash" && typeof e.input?.command === "string" ? e.input.command : void 0;
+}
+function registerNudge(pi, run = defaultRunner(), skillMd = readSkill()) {
+  if (!nudgeEnabled()) return;
+  const rule = skillMd === void 0 ? void 0 : keepDrivingRule(skillMd);
+  if (rule === void 0) return;
+  const armed = /* @__PURE__ */ new Set();
+  let fired = false;
+  pi.on("input", () => {
+    armed.clear();
+    fired = false;
+  });
+  pi.on("tool_call", (event) => {
+    const cmd = bashCommand(event);
+    if (cmd === void 0) return;
+    for (const ws of dispatchedWorkstreams(cmd) ?? []) armed.add(ws);
+  });
+  pi.on("agent_before_settle", async (event) => {
+    if (fired || armed.size === 0) return;
+    if (outcomeOf(event) !== "completed") return;
+    fired = true;
+    const refs = await inProgress(run, [...armed]);
+    if (refs === void 0 || refs.length === 0) return;
+    const text = nudgeText(rule, refs);
+    const logWs = [...armed].find((w) => w !== "");
+    await run([
+      "log",
+      ...logWs ? ["-w", logWs] : [],
+      "--kind",
+      NUDGE_LOG_KIND,
+      `keep-driving: ${refs.length} in progress`
+    ]);
+    return {
+      entries: [
+        { type: "custom_message", customType: NUDGE_MESSAGE_TYPE, content: text, display: true }
+      ],
+      continue: true
+    };
+  });
+}
+
 // extension/mu-pi.ts
-var EXT_VERSION = true ? "3.2.1" : void 0;
+var EXT_VERSION = true ? "3.4.0" : void 0;
 var FRESH_COMMAND = "mu-fresh";
 var FRESH_TIMEOUT_MS = 3e4;
+function commandName(name) {
+  return `mu-${name}`;
+}
+var COMMAND_TIMEOUT_MS = 3e4;
 var LAST_TEXT_MAX_BYTES = 64 * 1024;
 var LAST_TEXT_TRUNCATED = "[truncated, see pane]";
 var LIVE_PROBE_MS = 500;
@@ -444,9 +610,9 @@ function detectPiVersion() {
     if (!entry) return void 0;
     let dir = dirname(realpathSync(entry));
     for (let i = 0; i < 6; i++) {
-      const pkgPath = join2(dir, "package.json");
-      if (existsSync2(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      const pkgPath = join3(dir, "package.json");
+      if (existsSync3(pkgPath)) {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
         if (typeof pkg === "object" && pkg !== null) {
           const { name, version } = pkg;
           if (typeof name === "string" && /pi/.test(name) && typeof version === "string") {
@@ -529,8 +695,31 @@ function reasonOf(event) {
   const r = typeof event === "object" && event !== null ? event.reason : void 0;
   return typeof r === "string" ? r : void 0;
 }
+function promptsDir(from = import.meta.url) {
+  let here;
+  try {
+    here = dirname(fileURLToPath2(from));
+  } catch {
+    return void 0;
+  }
+  for (const up of ["..", "../.."]) {
+    const d = join3(here, up, "prompts");
+    if (existsSync3(join3(d, "ultrathink.md"))) return d;
+  }
+  return void 0;
+}
+function registerPrompts(pi) {
+  pi.on("resources_discover", () => {
+    const d = promptsDir();
+    if (!d) return {};
+    const paths = readdirSync(d).filter((f) => f.endsWith(".md")).sort().map((f) => join3(d, f));
+    return { promptPaths: paths };
+  });
+}
 function muPi(pi) {
   registerDelegate(pi);
+  registerPrompts(pi);
+  registerNudge(pi);
   serveCtl(pi);
 }
 function serveCtl(pi) {
@@ -565,6 +754,12 @@ function serveCtl(pi) {
     g.fresh = void 0;
     f.settle(r);
   };
+  const settleCommand = (r) => {
+    const c = g.command;
+    if (!c) return;
+    g.command = void 0;
+    c.settle(r);
+  };
   pi.on("agent_start", (_e, c) => {
     g.ctx = c;
     g.state = "busy";
@@ -603,10 +798,69 @@ function serveCtl(pi) {
       settleFresh({ v: V, ok: true, ...status() });
     }
   });
+  pi.on("session_before_compact", () => {
+    if (g.command?.name === "compact") settleCommand({ v: V, ok: true, ...status() });
+  });
+  async function runCommand(name, ctx) {
+    const c = g.command;
+    if (c?.name !== name) return;
+    const ok = () => settleCommand({ v: V, ok: true, ...status() });
+    const failWith = (e) => settleCommand(fail(e instanceof Error ? e.message : String(e)));
+    try {
+      if (name === "new") {
+        const r = await ctx.newSession();
+        if (r.cancelled) settleCommand(fail("new session was cancelled"));
+        else ok();
+      } else if (name === "reload") {
+        await ctx.reload();
+        if (c.reloaded) ok();
+        else settleCommand(fail("pi did not reload (busy or compacting)"));
+      } else {
+        ctx.compact({
+          ...c.instructions !== void 0 ? { customInstructions: c.instructions } : {},
+          onComplete: ok,
+          onError: failWith
+        });
+      }
+    } catch (e) {
+      failWith(e);
+    }
+  }
+  for (const name of CTL_COMMANDS) {
+    pi.registerCommand(commandName(name), {
+      description: `mu internal: /${name} requested over the control socket (mu agent send '/${name}')`,
+      handler: (_args, ctx) => runCommand(name, ctx)
+    });
+  }
+  function command(req) {
+    const name = CTL_COMMANDS.find((n) => n === req.name);
+    if (name === void 0) {
+      return fail(`command must be one of ${CTL_COMMANDS.join(", ")}`);
+    }
+    if (g.fresh || g.command) return fail("a fresh send or command is already in progress");
+    const busy = !(g.ctx?.isIdle() ?? g.state === "idle");
+    if (busy && req.force !== true) return fail("busy");
+    const instructions = str(req, "instructions");
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => settleCommand(fail(`/${name} timed out`)), COMMAND_TIMEOUT_MS);
+      g.command = {
+        name,
+        ...instructions !== void 0 ? { instructions } : {},
+        reloaded: false,
+        settle: (r) => {
+          clearTimeout(timer);
+          resolve(r);
+        }
+      };
+      Promise.resolve(
+        g.pi.sendUserMessage(`/${commandName(name)}`, { expandPromptTemplates: true })
+      ).catch((e) => settleCommand(fail(e instanceof Error ? e.message : String(e))));
+    });
+  }
   function fresh(req) {
     const text = str(req, "text");
     if (text === void 0) return fail("fresh needs a string text");
-    if (g.fresh) return fail("a fresh send is already in progress");
+    if (g.fresh || g.command) return fail("a fresh send or command is already in progress");
     const busy = !(g.ctx?.isIdle() ?? g.state === "idle");
     if (busy && req.force !== true) return fail("busy");
     return new Promise((resolve) => {
@@ -648,6 +902,8 @@ function serveCtl(pi) {
       }
       case "fresh":
         return fresh(req);
+      case "command":
+        return command(req);
       case "wait":
         return wait(num(req, "afterRuns"), num(req, "timeoutMs"), conn);
       case "abort":
@@ -720,7 +976,7 @@ function serveCtl(pi) {
       return;
     }
     rmSync(sockPath, { force: true });
-    const tmp = join2(dirname(sockPath), `.${process.pid.toString(36)}${(++bindSeq).toString(36)}`);
+    const tmp = join3(dirname(sockPath), `.${process.pid.toString(36)}${(++bindSeq).toString(36)}`);
     rmSync(tmp, { force: true });
     const s = createServer(onConnection);
     await new Promise((resolve, reject) => {
@@ -745,8 +1001,9 @@ function serveCtl(pi) {
     g.server = s;
     g.ino = inodeOf(sockPath);
   }
-  pi.on("session_start", async (_e, c) => {
+  pi.on("session_start", async (e, c) => {
     g.ctx = c;
+    if (reasonOf(e) === "reload" && g.command?.name === "reload") g.command.reloaded = true;
     const s = g.server;
     if (s) {
       if (g.ino !== void 0 && inodeOf(sockPath) === g.ino) return;
@@ -769,18 +1026,22 @@ function serveCtl(pi) {
     if (!s) return;
     g.waiters.clear();
     settleFresh(fail("pi is shutting down"));
+    settleCommand(fail("pi is shutting down"));
     for (const c of g.conns) c.destroy();
     await new Promise((resolve) => s.close(() => resolve()));
     if (ino !== void 0 && inodeOf(sockPath) === ino) rmSync(sockPath, { force: true });
   });
 }
 export {
+  COMMAND_TIMEOUT_MS,
   FRESH_COMMAND,
   FRESH_TIMEOUT_MS,
   LAST_TEXT_MAX_BYTES,
   LAST_TEXT_TRUNCATED,
   LIVE_PROBE_MS,
+  commandName,
   muPi as default,
-  lastAssistantText
+  lastAssistantText,
+  promptsDir
 };
 //# sourceMappingURL=mu-pi.js.map