@mu-crew/mu 3.2.0 → 3.3.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
+  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) {
@@ -39,13 +43,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 +62,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 +92,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 +167,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 +213,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 +235,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 +253,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 +292,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 +323,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 +388,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 +422,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}
@@ -294,10 +431,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.0" : void 0;
+var EXT_VERSION = true ? "3.3.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;
@@ -311,9 +581,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") {
@@ -370,7 +640,7 @@ ${LAST_TEXT_TRUNCATED}`;
 }
 function inodeOf(path) {
   try {
-    return statSync(path).ino;
+    return statSync2(path).ino;
   } catch {
     return void 0;
   }
@@ -396,8 +666,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) {
@@ -432,6 +725,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";
@@ -470,10 +769,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) => {
@@ -515,6 +873,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":
@@ -587,7 +947,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) => {
@@ -612,8 +972,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;
@@ -636,18 +997,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