@mu-crew/mu 3.6.2 → 3.8.0

package/dist/extension/mu-pi.js

@@ -23,6 +23,7 @@ var CTL_OPS = [
   "send",
   "wait",
   "abort",
+  "interrupt",
   "fresh",
   "command"
 ];
@@ -152,6 +153,23 @@ ${agent.lastText ?? ""}`;
       return `${who}: mu agent wait gave no result. ${fate}${ws}${tailBlock}`;
   }
 }
+var RECORD_NOTE_MAX = 4e3;
+var RECORD_FALLBACK_TAIL = 1500;
+var VERDICT_LINE = /^[\s>*_`-]*VERDICT:/;
+var EVIDENCE_LINE = /^[\s>*_`-]*EVIDENCE:/;
+function recordNote(label, name, outcome, lastText, elapsedMs) {
+  if (outcome !== "done" || !lastText?.trim())
+    return `REFUTER ${label}: no verdict (${outcome === "done" ? "empty" : outcome ?? "no result"})`;
+  const lines = lastText.trimEnd().split("\n");
+  let at = -1;
+  for (let i = lines.length - 1; i >= 0 && at < 0; i--)
+    if (VERDICT_LINE.test(lines[i] ?? "")) at = i;
+  const body = at >= 0 ? [lines[at] ?? "", ...lines.slice(at + 1).filter((l) => EVIDENCE_LINE.test(l))].join("\n") : `NO VERDICT LINE: ${lastText.trimEnd().slice(-RECORD_FALLBACK_TAIL)}`;
+  const note = `REFUTER ${label} (${name}, ${formatElapsed(elapsedMs)}):
+${body}`;
+  const mark = "\n[truncated]";
+  return note.length <= RECORD_NOTE_MAX ? note : note.slice(0, RECORD_NOTE_MAX - mark.length) + mark;
+}
 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(/-+$/, "");
@@ -200,7 +218,7 @@ function registerDelegate(pi, run = defaultRunner()) {
       const q = queue.shift();
       if (!q) break;
       starting++;
-      void start(q.params, void 0, q.ctx, q.handle).then(
+      void start(q.params, void 0, q.ctx, q.handle, q.record).then(
         () => {
         },
         (e) => {
@@ -288,7 +306,35 @@ function registerDelegate(pi, run = defaultRunner()) {
       };
     }
   }
-  async function deliver(name, wait, keep, extras) {
+  const recordLabel = (params, name) => typeof params.label === "string" && params.label.trim() ? params.label.trim() : name;
+  async function resolveRecord(raw) {
+    if (raw === void 0) return void 0;
+    const r = raw;
+    const task = typeof r?.task === "string" ? r.task.trim() : "";
+    if (!task) throw new Error("mu_delegate: record.task must name a task");
+    const ws = typeof r?.workstream === "string" ? r.workstream.trim() : "";
+    const shown = await mu(["task", "show", task, ...ws ? ["-w", ws] : [], "--json"]);
+    const out = json(shown);
+    const t = out?.task;
+    if (shown.code !== 0 || typeof t?.name !== "string" || typeof t.workstreamName !== "string") {
+      const why = typeof out?.message === "string" ? out.message : (shown.stderr || shown.stdout).trim();
+      throw new Error(
+        `mu_delegate: record task ${ws ? `${ws}/` : ""}${task} not found (exit ${shown.code}): ${why}. Nothing spawned.`
+      );
+    }
+    return { workstream: t.workstreamName, task: t.name };
+  }
+  async function writeRecord(rec, name, text) {
+    const where = `${rec.workstream}/${rec.task}`;
+    try {
+      const r = await mu(["task", "note", rec.task, "-w", rec.workstream, "--author", name, text]);
+      if (r.code === 0) return `Recorded on ${where} as a note.`;
+      return `Recording on ${where} failed (exit ${r.code}): ${(r.stderr || r.stdout).trim()}. Record it yourself.`;
+    } catch (e) {
+      return `Recording on ${where} failed: ${e instanceof Error ? e.message : String(e)}. Record it yourself.`;
+    }
+  }
+  async function deliver(name, wait, keep, extras, record) {
     const agent = json(wait)?.agents?.[0];
     const outcome = agent?.outcome;
     const tail = outcome === "done" || outcome === "timeout" || outcome === "pending" || outcome === "error" ? void 0 : (await mu(["agent", "read", name, "-n", "50", "-w", W])).stdout;
@@ -303,10 +349,18 @@ function registerDelegate(pi, run = defaultRunner()) {
       failed.add(name);
       showStatus();
     }
+    const recorded = record ? await writeRecord(
+      record.target,
+      name,
+      recordNote(record.label, name, outcome, agent?.lastText, extras.elapsedMs ?? 0)
+    ) : void 0;
+    const message = delegateMessage(name, agent, pane, { ...extras, ...tail ? { tail } : {} });
     await pi.sendMessage(
       {
         customType: DELEGATE_MESSAGE_TYPE,
-        content: delegateMessage(name, agent, pane, { ...extras, ...tail ? { tail } : {} }),
+        content: recorded ? `${message}
+
+${recorded}` : message,
         display: true,
         details: {
           name,
@@ -321,7 +375,7 @@ function registerDelegate(pi, run = defaultRunner()) {
       { deliverAs: "followUp", triggerTurn: true }
     );
   }
-  async function start(params, signal, ctx, queuedAs) {
+  async function start(params, signal, ctx, queuedAs, record) {
     let slotHeld = true;
     const freeSlot = () => {
       if (slotHeld) {
@@ -347,35 +401,68 @@ function registerDelegate(pi, run = defaultRunner()) {
         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 };
+      const entry = {
+        abort: new AbortController(),
+        cancelling: false,
+        ...record ? { record: { target: record, label: recordLabel(params, name) } } : {}
+      };
       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, brief ? `${brief}
+      const waitArgs = (after) => [
+        "agent",
+        "wait",
+        name,
+        "-w",
+        W,
+        "--json",
+        "--timeout",
+        String(timeoutS),
+        ...after !== void 0 ? ["--after-runs", String(after)] : []
+      ];
+      const plain = new AbortController();
+      entry.abort.signal.addEventListener("abort", () => plain.abort(), { once: true });
+      let waiting = mu(waitArgs(), plain.signal);
+      const sent = await mu([
+        "agent",
+        "send",
+        name,
+        brief ? `${brief}
 
-${task}` : task, "-w", W]);
+${task}` : task,
+        "-w",
+        W,
+        "--json"
+      ]);
       if (sent.code !== 0) {
-        entry.abort.abort();
+        plain.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 runs = json(sent)?.runs;
+      if (typeof runs === "number") {
+        plain.abort();
+        waiting = mu(waitArgs(runs), entry.abort.signal);
+      }
       const settle = async (r) => {
         forget(name);
         try {
-          await deliver(name, r, keep, {
-            timeoutS,
-            elapsedMs: Date.now() - started,
-            ...queuedAs ? { queuedAs } : {},
-            ...attach ? { attach } : {},
-            ...workspace ? { workspace } : {}
-          });
+          await deliver(
+            name,
+            r,
+            keep,
+            {
+              timeoutS,
+              elapsedMs: Date.now() - started,
+              ...queuedAs ? { queuedAs } : {},
+              ...attach ? { attach } : {},
+              ...workspace ? { workspace } : {}
+            },
+            entry.record
+          );
         } catch (e) {
           await Promise.resolve(
             pi.sendMessage(
@@ -420,7 +507,7 @@ ${task}` : task, "-w", W]);
   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 (at most ${delegateMax()} run at once; up to ${DELEGATE_QUEUE_FACTOR * delegateMax()} more are queued and start as slots free). 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, or a refuter of a claim, plan or fix before you act on it; call it several times to fan out in parallel (at most ${delegateMax()} run at once; up to ${DELEGATE_QUEUE_FACTOR * delegateMax()} more are queued and start as slots free). 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. When the check judges a mu task, set record so its verdict lands on that task; leave it out when there is no task.`,
     promptSnippet: "Subagent: delegate a self-contained task to a background pi agent; its answer arrives later as a follow-up",
     parameters: {
       type: "object",
@@ -454,6 +541,16 @@ ${task}` : task, "-w", W]);
         keep: {
           type: "boolean",
           description: "Keep the pane after it finishes, to talk to it again"
+        },
+        record: {
+          type: "object",
+          description: "When the answer arrives, write its VERDICT/EVIDENCE onto this task as a note (for a check that judges a mu task; omit with no task); task may be <ws>/<task>.",
+          properties: {
+            task: { type: "string" },
+            workstream: { type: "string" }
+          },
+          required: ["task"],
+          additionalProperties: false
         }
       },
       required: ["task"],
@@ -472,10 +569,11 @@ ${task}` : task, "-w", W]);
         const 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 record = await resolveRecord(params.record);
       const max = delegateMax();
       if (inflight.size + starting < max) {
         starting++;
-        return start(params, signal, ctx);
+        return start(params, signal, ctx, void 0, record);
       }
       if (queue.length >= DELEGATE_QUEUE_FACTOR * max)
         throw new Error(
@@ -488,7 +586,8 @@ ${task}` : task, "-w", W]);
           ...params,
           cwd: typeof params.cwd === "string" && params.cwd ? params.cwd : ctx?.cwd ?? process.cwd()
         },
-        ctx
+        ctx,
+        ...record ? { record } : {}
       });
       showStatus();
       return {
@@ -521,10 +620,13 @@ ${task}` : task, "-w", W]);
       if (!name) throw new Error("mu_delegate_cancel needs a name");
       const qi = queue.findIndex((q) => q.handle === name);
       if (qi >= 0) {
-        queue.splice(qi, 1);
+        const [q] = queue.splice(qi, 1);
         showStatus();
+        const recorded = q?.record ? ` ${await writeRecord(q.record, name, recordNote(recordLabel(q.params, name), name, "cancelled", void 0, 0))}` : "";
         return {
-          content: [{ type: "text", text: `Dropped ${name} from the queue; it never started.` }],
+          content: [
+            { type: "text", text: `Dropped ${name} from the queue; it never started.${recorded}` }
+          ],
           details: { name, workstream: W }
         };
       }
@@ -546,6 +648,8 @@ ${task}` : task, "-w", W]);
       }
       failed.delete(name);
       let text = `Aborted ${W}/${name}.`;
+      if (entry?.record)
+        text += ` ${await writeRecord(entry.record.target, name, recordNote(entry.record.label, name, "cancelled", void 0, 0))}`;
       if (params.keep === true) text += " Pane kept.";
       else {
         const c = await mu(["agent", "close", name, "-w", W]);
@@ -582,9 +686,14 @@ import { join as join2 } from "path";
 var NUDGE_MESSAGE_TYPE = "mu-keep-driving";
 var NUDGE_LOG_KIND = "nudge";
 var CLOSE_NUDGE_MESSAGE_TYPE = "mu-close-task";
+var REFUTE_NUDGE_MESSAGE_TYPE = "mu-refute-brief";
 var MARK_START = "<!-- mu:keep-driving -->";
 var MARK_END = "<!-- /mu:keep-driving -->";
 var WAIT_HINT_MAX = 8;
+var notNested = () => false;
+function noUI(ctx) {
+  return ctx?.hasUI === false;
+}
 function nudgeEnabled(env = process.env) {
   return env.MU_NUDGE !== "0";
 }
@@ -604,8 +713,7 @@ function readSkill() {
 }
 function dispatchedWorkstreams(command) {
   const found = /* @__PURE__ */ new Set();
-  for (const seg of command.split(/&&|\|\||;|\n|\|/)) {
-    const words = seg.trim().split(/\s+/);
+  for (const words of shellSegments(command)) {
     const at = words.findIndex((w) => w === "mu" || w.endsWith("/mu"));
     if (at < 0) continue;
     const [noun, verb] = [words[at + 1], words[at + 2]];
@@ -615,19 +723,78 @@ function dispatchedWorkstreams(command) {
     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 (w === "-w" || w === "--workstream") ws = words[k + 1] ?? "";
+      else if (w.startsWith("--workstream=")) ws = w.slice("--workstream=".length);
     }
     if (ws === "" && isClaimFor) {
       const ref = words[at + 3] ?? "";
-      if (ref.includes("/")) ws = unquote(ref.split("/")[0] ?? "");
+      if (ref.includes("/")) ws = ref.split("/")[0] ?? "";
     }
     if (ws !== "scratch") found.add(ws);
   }
   return found.size > 0 ? [...found] : void 0;
 }
-function unquote(s) {
-  return s.replace(/^['"]|['"]$/g, "");
+var CLAIM_VALUE_OPTS = /* @__PURE__ */ new Set(["--for", "-f", "-w", "--workstream", "--evidence", "--actor"]);
+function shellSegments(command) {
+  const segs = [];
+  let words = [];
+  let word;
+  const endWord = () => {
+    if (word !== void 0) words.push(word);
+    word = void 0;
+  };
+  const endSeg = () => {
+    endWord();
+    if (words.length > 0) segs.push(words);
+    words = [];
+  };
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i] ?? "";
+    if (c === "'" || c === '"') {
+      const close = command.indexOf(c, i + 1);
+      const end = close < 0 ? command.length : close;
+      word = (word ?? "") + command.slice(i + 1, end);
+      i = end;
+    } else if (c === "\\" && i + 1 < command.length) {
+      word = (word ?? "") + command[++i];
+    } else if (c === ";" || c === "|" || c === "\n" || c === "&" && command[i + 1] === "&") {
+      if (c !== ";" && c !== "\n" && command[i + 1] === c) i++;
+      endSeg();
+    } else if (/\s/.test(c)) {
+      endWord();
+    } else {
+      word = (word ?? "") + c;
+    }
+  }
+  endSeg();
+  return segs;
+}
+function dispatchedTasks(command) {
+  const out = [];
+  for (const words of shellSegments(command)) {
+    if (words[0] !== "mu" && !words[0]?.endsWith("/mu")) continue;
+    if (words[1] !== "task" || words[2] !== "claim") continue;
+    let ws = "";
+    let id;
+    let isFor = false;
+    for (let k = 3; k < words.length; k++) {
+      const w = words[k] ?? "";
+      const [opt, eq] = w.startsWith("--") && w.includes("=") ? w.split("=", 2) : [w, void 0];
+      if (opt === "--for" || opt === "-f") isFor = true;
+      if (opt === "-w" || opt === "--workstream") ws = eq ?? words[k + 1] ?? "";
+      if (CLAIM_VALUE_OPTS.has(opt ?? "")) {
+        if (eq === void 0) k++;
+      } else if (id === void 0 && !w.startsWith("-")) id = w;
+    }
+    if (!isFor || id === void 0) continue;
+    const slash = id.indexOf("/");
+    if (slash >= 0) {
+      if (ws === "") ws = id.slice(0, slash);
+      id = id.slice(slash + 1);
+    }
+    if (ws !== "scratch") out.push({ ws, id });
+  }
+  return out;
 }
 async function inProgress(run, workstreams) {
   const named = workstreams.filter((w) => w !== "");
@@ -667,7 +834,7 @@ function bashCommand(event) {
   const e = event;
   return e.toolName === "bash" && typeof e.input?.command === "string" ? e.input.command : void 0;
 }
-function registerNudge(pi, run = defaultRunner(), skillMd = readSkill()) {
+function registerNudge(pi, run = defaultRunner(), skillMd = readSkill(), nested = notNested) {
   if (!nudgeEnabled()) return;
   const rule = skillMd === void 0 ? void 0 : keepDrivingRule(skillMd);
   if (rule === void 0) return;
@@ -683,7 +850,7 @@ function registerNudge(pi, run = defaultRunner(), skillMd = readSkill()) {
     for (const ws of dispatchedWorkstreams(cmd) ?? []) armed.add(ws);
   });
   pi.on("agent_before_settle", async (event) => {
-    if (fired || armed.size === 0) return;
+    if (fired || armed.size === 0 || nested()) return;
     if (outcomeOf(event) !== "completed") return;
     fired = true;
     const refs = await inProgress(run, [...armed]);
@@ -732,7 +899,7 @@ function closeNudgeText(workstream, names) {
     "If you are blocked or need an answer, say so in one line and stop; the orchestrator will read your pane."
   ].join("\n");
 }
-function registerCloseNudge(pi, run = defaultRunner(), env = process.env) {
+function registerCloseNudge(pi, run = defaultRunner(), env = process.env, nested = notNested) {
   if (!nudgeEnabled(env)) return;
   const me = workerIdentity(env);
   if (me === void 0) return;
@@ -740,8 +907,8 @@ function registerCloseNudge(pi, run = defaultRunner(), env = process.env) {
   pi.on("input", () => {
     fired = false;
   });
-  pi.on("agent_before_settle", async (event) => {
-    if (fired) return;
+  pi.on("agent_before_settle", async (event, ctx) => {
+    if (fired || nested() || noUI(ctx)) return;
     if (outcomeOf(event) !== "completed") return;
     fired = true;
     const names = await ownedInProgress(run, me.agent, me.workstream);
@@ -767,9 +934,67 @@ function registerCloseNudge(pi, run = defaultRunner(), env = process.env) {
     };
   });
 }
+var REFUTE_MARK = /^(REFUTER |VERDICT:|REFUTE-EXEMPT:)/m;
+async function briefRefuted(run, ws, id) {
+  const r = await run(["task", "notes", id, ...ws ? ["-w", ws] : [], "--json"]);
+  if (r.code !== 0) return void 0;
+  try {
+    const json = JSON.parse(r.stdout);
+    return (json.items ?? []).some((n) => REFUTE_MARK.test(n.content ?? ""));
+  } catch {
+    return void 0;
+  }
+}
+function refuteNudgeText(refs) {
+  return `[mu] dispatched ${refs.join(", ")} with an unrefuted brief: refute it (delegate, record) or note REFUTE-EXEMPT: <why>`;
+}
+function registerRefuteNudge(pi, run = defaultRunner(), nested = notNested) {
+  if (!nudgeEnabled()) return;
+  const armed = /* @__PURE__ */ new Map();
+  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 t of dispatchedTasks(cmd)) {
+      if (!t.id.startsWith("review_")) armed.set(`${t.ws}/${t.id}`, t);
+    }
+  });
+  pi.on("agent_before_settle", async (event, ctx) => {
+    if (fired || armed.size === 0 || nested() || noUI(ctx)) return;
+    if (outcomeOf(event) !== "completed") return;
+    fired = true;
+    const refs = [];
+    for (const [ref, t] of armed) {
+      if (await briefRefuted(run, t.ws, t.id) === false) refs.push(ref);
+    }
+    if (refs.length === 0) return;
+    const logWs = [...armed.values()].find((t) => t.ws !== "")?.ws;
+    await run([
+      "log",
+      ...logWs ? ["-w", logWs] : [],
+      "--kind",
+      NUDGE_LOG_KIND,
+      `refute: ${refs.join(", ")}`
+    ]);
+    return {
+      entries: [
+        {
+          type: "custom_message",
+          customType: REFUTE_NUDGE_MESSAGE_TYPE,
+          content: refuteNudgeText(refs),
+          display: true
+        }
+      ]
+    };
+  });
+}
 
 // extension/mu-pi.ts
-var EXT_VERSION = true ? "3.6.2" : void 0;
+var EXT_VERSION = true ? "3.8.0" : void 0;
 var FRESH_COMMAND = "mu-fresh";
 var FRESH_TIMEOUT_MS = 3e4;
 function commandName(name) {
@@ -908,16 +1133,17 @@ function registerPrompts(pi) {
     return { promptPaths: paths };
   });
 }
-function muPi(pi) {
-  registerDelegate(pi);
+function muPi(pi, run = defaultRunner()) {
+  registerDelegate(pi, run);
   registerPrompts(pi);
-  registerNudge(pi);
-  registerCloseNudge(pi);
-  serveCtl(pi);
+  const nested = serveCtl(pi);
+  registerNudge(pi, run, void 0, nested);
+  registerCloseNudge(pi, run, process.env, nested);
+  registerRefuteNudge(pi, run, nested);
 }
 function serveCtl(pi) {
   const sock = process.env.MU_CTL_SOCK;
-  if (!sock) return;
+  if (!sock) return () => false;
   const sockPath = sock;
   const piVersion = detectPiVersion();
   const map = sharedMap();
@@ -1092,9 +1318,10 @@ function serveCtl(pi) {
         const text = str(req, "text");
         if (text === void 0) return fail("send needs a string text");
         const mode = req.mode === "steer" ? "steer" : "followUp";
+        const before = status();
         if (g.ctx?.isIdle() ?? g.state === "idle") await g.pi.sendUserMessage(text);
         else await g.pi.sendUserMessage(text, { deliverAs: mode });
-        return { v: V, ok: true, state: g.state };
+        return { v: V, ok: true, ...before };
       }
       case "fresh":
         return fresh(req);
@@ -1106,10 +1333,28 @@ function serveCtl(pi) {
         if (!g.ctx) return fail("no pi context yet");
         g.ctx.abort();
         return { v: V, ok: true, state: g.state };
+      case "interrupt":
+        return interrupt(req, conn);
       default:
         return { ...fail(`${UNKNOWN_OP_PREFIX}${String(req.op)}`), ops: [...CTL_OPS] };
     }
   }
+  async function interrupt(req, conn) {
+    const text = str(req, "text");
+    if (text === void 0) return fail("interrupt needs a string text");
+    const wasBusy = !(g.ctx?.isIdle() ?? g.state === "idle");
+    const { pending } = status();
+    if (wasBusy) {
+      if (!g.ctx) return fail("no pi context yet");
+      const settled = wait(g.runs, num(req, "timeoutMs"), conn);
+      g.ctx.abort();
+      const w = await settled;
+      if (!w.ok) return w;
+    }
+    const before = status();
+    await g.pi.sendUserMessage(text);
+    return { v: V, ok: true, ...before, pending, wasBusy };
+  }
   const settledRun = () => ({
     lastText: g.lastText,
     ...g.lastError !== void 0 ? { lastError: g.lastError } : {}
@@ -1126,7 +1371,10 @@ function serveCtl(pi) {
         conn.off("close", onClose);
         resolve(r);
       };
-      const waiter = () => done({ v: V, ok: true, ...status(), ...settledRun() });
+      const waiter = () => {
+        if (afterRuns !== void 0 && g.runs <= afterRuns) return;
+        done({ v: V, ok: true, ...status(), ...settledRun() });
+      };
       const onClose = () => done(fail("client closed"));
       g.waiters.add(waiter);
       conn.on("close", onClose);
@@ -1169,8 +1417,9 @@ function serveCtl(pi) {
   async function bind() {
     mkdirSync(dirname(sockPath), { recursive: true, mode: 448 });
     if (await socketIsLive(sockPath)) {
+      g.nested = true;
       process.stderr.write(
-        `mu: control socket ${sockPath} is served by another pi; this pi will not take it
+        `mu: control socket ${sockPath} is served by another pi; nested pi: mu agent features off
 `
       );
       return;
@@ -1192,14 +1441,18 @@ function serveCtl(pi) {
     } catch (e) {
       s.close();
       if (e.code !== "EEXIST") throw e;
-      process.stderr.write(`mu: control socket ${sockPath} was taken by another pi
-`);
+      g.nested = true;
+      process.stderr.write(
+        `mu: control socket ${sockPath} was taken by another pi; nested pi: mu agent features off
+`
+      );
       return;
     } finally {
       rmSync(tmp, { force: true });
     }
     g.server = s;
     g.ino = inodeOf(sockPath);
+    g.nested = false;
   }
   pi.on("session_start", async (e, c) => {
     g.ctx = c;
@@ -1231,6 +1484,7 @@ function serveCtl(pi) {
     await new Promise((resolve) => s.close(() => resolve()));
     if (ino !== void 0 && inodeOf(sockPath) === ino) rmSync(sockPath, { force: true });
   });
+  return () => g.nested === true;
 }
 export {
   COMMAND_TIMEOUT_MS,