@mu-crew/mu 3.13.3 → 4.1.0

package/dist/extension/mu-pi.js

@@ -1,10 +1,10 @@
 // extension/mu-pi.ts
+import { randomUUID } from "crypto";
 import {
   chmodSync,
   existsSync as existsSync3,
   linkSync,
   mkdirSync as mkdirSync2,
-  readdirSync,
   readFileSync as readFileSync3,
   realpathSync,
   rmSync,
@@ -12,7 +12,6 @@ import {
 } from "fs";
 import { connect, createServer } from "net";
 import { dirname, join as join4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/ctl/protocol.ts
 var CTL_PROTOCOL_VERSION = 1;
@@ -27,6 +26,10 @@ var CTL_OPS = [
   "fresh",
   "command"
 ];
+var CTL_FEATURES = ["incarnation", "msgId", "fence"];
+var CTL_MSGID_MEMORY = 64;
+var CTL_MSGID_MAX_LENGTH = 64;
+var INCARNATION_MISMATCH = "incarnation mismatch";
 var UNKNOWN_OP_PREFIX = "unknown op: ";
 function encode(msg) {
   return `${JSON.stringify(msg)}
@@ -43,59 +46,72 @@ var LineDecoder = class {
 };
 
 // extension/delegate.ts
-import { execFile } from "child_process";
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
-import { delimiter, join as join2 } from "path";
-import { fileURLToPath } from "url";
+import { randomBytes } from "crypto";
+import { statSync } from "fs";
 
-// src/state-dir.ts
-import { homedir } from "os";
-import { isAbsolute, join } from "path";
-function defaultCacheDir() {
-  const xdg = process.env.XDG_CACHE_HOME;
-  return join(xdg !== void 0 && isAbsolute(xdg) ? xdg : join(homedir(), ".cache"), "mu");
+// src/workstream-scope.ts
+function workstreamNameProblem(value, flag = "-w/--workstream") {
+  if (value.length > 0 && value.trim().length === 0) {
+    return `${flag} got a blank (whitespace-only) value ${JSON.stringify(value)}. Pass a workstream name.`;
+  }
+  if (value.length === 0 || value !== value.trim()) {
+    return `${flag} got ${JSON.stringify(value)}: pass a bare workstream name with no surrounding whitespace.`;
+  }
+  if (/[\s,/\p{Cc}]/u.test(value)) {
+    return `${flag} got ${JSON.stringify(value)}: a workstream name has no whitespace, ',' or '/'.`;
+  }
+  return void 0;
+}
+function qualifiedRefProblem(raw) {
+  const slash = raw.indexOf("/");
+  if (slash === -1) return void 0;
+  const flag = `qualified ref ${JSON.stringify(raw)}:`;
+  const prefix = workstreamNameProblem(raw.slice(0, slash), flag);
+  if (prefix !== void 0) return prefix;
+  const name = raw.slice(slash + 1);
+  if (name === "" || name !== name.trim() || /[\s\p{Cc}]/u.test(name)) {
+    return `${flag} the name after '/' must be non-empty with no whitespace.`;
+  }
+  return void 0;
 }
 
-// extension/delegate.ts
-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";
-var PENDING_CHANNEL = "murmur:pending";
-function delegateStatus(running, starting = 0, queued = 0, failed = 0, pending = 0) {
-  const parts = [];
-  if (running > 0) parts.push(`${running} delegate${running === 1 ? "" : "s"} running`);
-  if (starting > 0) parts.push(`${starting} starting`);
-  if (queued > 0) parts.push(`${queued} queued`);
-  if (failed > 0) parts.push(`${failed} failed`);
-  if (pending > 0) parts.push(`${pending} result${pending === 1 ? "" : "s"} pending`);
-  return parts.length > 0 ? parts.join(", ") : void 0;
+// extension/delegate-args.ts
+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;
 }
-var DELEGATE_TIMEOUT_S = 3600;
-var DELEGATE_MAX_DEFAULT = 16;
-var DELEGATE_QUEUE_FACTOR = 4;
-var PRUNE_FAILED_MS = 3e4;
-function delegateMax(env = process.env) {
-  const n = Number(env.MU_DELEGATE_MAX);
-  return Number.isInteger(n) && n > 0 ? n : DELEGATE_MAX_DEFAULT;
+var MODEL_BARE_RE = /^[A-Za-z0-9._:/@+=-]+$/;
+function normalizeModel(raw) {
+  if (typeof raw !== "string") return void 0;
+  let m = raw.trim();
+  for (let prev = ""; prev !== m; ) {
+    prev = m;
+    m = m.replace(/^--model(?:=|\s+)/, "").replace(/^(["'`])(.*)\1$/s, "$2").trim();
+  }
+  return m && !/\s/.test(m) ? m : void 0;
 }
-var W = DELEGATE_WORKSTREAM;
-function delegateEnabled(env = process.env) {
-  if (env.MU_MANAGED_AGENT) return false;
-  if (env.MU_DELEGATE === "0") return false;
-  if (env.MU_MUX || env.HERDR_ENV === "1" || env.TMUX || env.TMUX_PANE) return true;
-  return onPath("tmux", env) || onPath("herdr", env);
+function shellArg(s) {
+  return MODEL_BARE_RE.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
 }
-function isDir(p) {
-  try {
-    return statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
+function modelCommand(cli, model, env = process.env) {
+  const override = env[`MU_${cli.toUpperCase().replace(/-/g, "_")}_COMMAND`];
+  const base = override && override.trim() !== "" ? override.trim() : cli;
+  return `${base} --model ${shellArg(model)}`;
 }
-function onPath(bin, env) {
-  return (env.PATH ?? "").split(delimiter).some((d) => d !== "" && existsSync(join2(d, bin)));
+
+// extension/mu-run.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+function childEnv(over) {
+  if (over === void 0) return void 0;
+  const env = { ...process.env };
+  for (const [k, v] of Object.entries(over)) {
+    if (v === void 0) delete env[k];
+    else env[k] = v;
+  }
+  return env;
 }
 function defaultRunner() {
   let cli;
@@ -104,19 +120,180 @@ function defaultRunner() {
     if (existsSync(p)) cli = p;
   } catch {
   }
-  return (args, signal) => new Promise((resolve) => {
-    const [cmd, argv] = cli ? [process.execPath, [cli, ...args]] : ["mu", [...args]];
-    execFile(
+  return (args, signal, stdin, opts) => cli ? runChild(process.execPath, [cli, ...args], signal, stdin, opts) : runChild("mu", args, signal, stdin, opts);
+}
+var ABORT_GRACE_MS = 1e4;
+function runChild(cmd, argv, signal, stdin, opts = {}) {
+  return new Promise((resolve) => {
+    let timer;
+    const env = childEnv(opts.env);
+    const child = execFile(
       cmd,
-      argv,
-      { maxBuffer: 16 * 1024 * 1024, ...signal ? { signal } : {} },
+      [...argv],
+      { maxBuffer: 16 * 1024 * 1024, ...env ? { env } : {} },
       (err, stdout, stderr) => {
-        const code = err ? typeof err.code === "number" ? err.code : 1 : 0;
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        const code = err ? typeof err.code === "number" ? err.code : err.signal ? 143 : 1 : 0;
         resolve({ code, stdout: String(stdout), stderr: String(stderr || err?.message || "") });
       }
     );
+    function onAbort() {
+      child.kill("SIGTERM");
+      timer = setTimeout(() => child.kill("SIGKILL"), opts.drainMs ?? ABORT_GRACE_MS);
+    }
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+    if (stdin !== void 0) {
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end(stdin);
+    }
   });
 }
+function parseEnvelope(stdout) {
+  try {
+    const v = JSON.parse(stdout);
+    if (typeof v !== "object" || v === null || typeof v.ok !== "boolean") return void 0;
+    const data = typeof v.data === "object" && v.data !== null ? v.data : {};
+    return v.ok ? data : { ...data, error: v.error, message: v.message };
+  } catch {
+    return void 0;
+  }
+}
+function parseOkEnvelope(stdout) {
+  try {
+    const v = JSON.parse(stdout);
+    if (typeof v !== "object" || v === null || v.ok !== true) return void 0;
+    return typeof v.data === "object" && v.data !== null ? v.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// extension/delegate-calls.ts
+var MuCallError = class extends Error {
+  constructor(verb, code, reason2) {
+    super(`mu delegates ${verb} failed (exit ${code}): ${reason2}`);
+    this.verb = verb;
+    this.code = code;
+  }
+  verb;
+  code;
+  name = "MuCallError";
+};
+var reason = (r) => {
+  const m = parseEnvelope(r.stdout)?.message;
+  return (typeof m === "string" ? m : r.stderr || r.stdout).trim();
+};
+async function call(run, verb, args, stdin) {
+  const r = await run(["delegates", verb, ...args, "--json"], void 0, stdin);
+  const out = r.code === 0 ? parseOkEnvelope(r.stdout) : void 0;
+  if (out === void 0) throw new MuCallError(verb, r.code, reason(r));
+  return out;
+}
+var rowOf = (data) => data.call ?? {};
+function callInfoOf(row) {
+  const rec = row.record;
+  return {
+    callId: String(row.callId),
+    caller: String(row.caller),
+    workstream: String(row.workstream),
+    task: String(row.task),
+    ...typeof row.wave === "string" ? { wave: row.wave } : {},
+    ...rec?.workstream && rec.task ? { record: { workstream: rec.workstream, task: rec.task } } : {},
+    request: row.request ?? { text: "" }
+  };
+}
+function callsApi(run) {
+  return {
+    /** Create the call (task + brief + row, atomically). `created: false`: this id already existed. */
+    async register(c, state) {
+      const q = c.request;
+      const args = [
+        c.callId,
+        "--caller",
+        c.caller,
+        "-w",
+        c.workstream,
+        "--text",
+        "-",
+        "--state",
+        state,
+        ...q.label ? ["--label", q.label] : [],
+        ...q.cli ? ["--cli", q.cli] : [],
+        ...q.model ? ["--model", q.model] : [],
+        ...q.cwd ? ["--cwd", q.cwd] : [],
+        ...q.workspace === true ? ["--workspace"] : [],
+        ...q.timeoutS !== void 0 ? ["--timeout", String(q.timeoutS)] : [],
+        ...q.keep === true ? ["--keep"] : [],
+        ...c.wave ? ["--wave", c.wave] : [],
+        ...c.record ? ["--record", `${c.record.workstream}/${c.record.task}`] : []
+      ];
+      const data = await call(run, "register", args, q.text);
+      const row = rowOf(data);
+      return {
+        call: callInfoOf(row),
+        state: row.state,
+        created: data.created === true
+      };
+    },
+    /** One admission step (a compare-and-set on the stored state). */
+    async mark(callId, to, extra = {}) {
+      await call(run, "mark", [
+        callId,
+        to,
+        ...extra.agent ? ["--agent", extra.agent] : [],
+        ...extra.error ? ["--error", extra.error] : []
+      ]);
+    },
+    /** The recorder: verdict note, report and close, in one op group. Idempotent. */
+    async finish(callId, o) {
+      const data = await call(
+        run,
+        "finish",
+        [
+          callId,
+          "--outcome",
+          o.outcome,
+          "--author",
+          o.author,
+          ...o.elapsedMs !== void 0 ? ["--elapsed-ms", String(Math.round(o.elapsedMs))] : [],
+          ...o.record === false ? ["--no-record"] : [],
+          ...o.text?.trim() ? ["--text", "-"] : []
+        ],
+        o.text?.trim() ? o.text : void 0
+      );
+      return data;
+    },
+    async show(callId) {
+      const row = rowOf(await call(run, "show", [callId]));
+      return {
+        call: callInfoOf(row),
+        state: row.state,
+        verdict: typeof row.verdict === "string" ? row.verdict : null
+      };
+    }
+  };
+}
+
+// extension/delegate-format.ts
+import { readFileSync } from "fs";
+
+// src/delegate-verdict.ts
+var VERDICT_LABELS = ["CONFIRMED", "REFUTED", "UNVERIFIED"];
+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`;
+}
+var LABEL_RE = new RegExp(`\\b(${VERDICT_LABELS.join("|")})\\b`);
+
+// extension/delegate-format.ts
+var DELEGATE_WORKSTREAM = "scratch";
+var DELEGATE_TIMEOUT_S = 3600;
 function lastAssistantTextIn(sessionFile) {
   let raw;
   try {
@@ -143,26 +320,17 @@ function lastAssistantTextIn(sessionFile) {
   return void 0;
 }
 function evidenceLines(x) {
-  return [
-    x.partial ? `Partial answer so far: ${x.partial}` : void 0,
-    x.sessionFile ? `Session: ${x.sessionFile}` : void 0
-  ].filter((v) => v !== void 0);
-}
-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`;
+  return x.sessionFile ? [`Session: ${x.sessionFile}`] : [];
 }
 function delegateMessage(name, agent, pane, x = {}) {
   const timeoutS = x.timeoutS ?? DELEGATE_TIMEOUT_S;
-  const who = `Delegate ${W}/${name}${x.queuedAs ? ` (queued as ${x.queuedAs})` : ""}`;
+  const W2 = x.workstream ?? DELEGATE_WORKSTREAM;
+  const who = `Delegate ${W2}/${name}${x.queuedAs ? ` (queued as ${x.queuedAs})` : ""}`;
   const took = x.elapsedMs !== void 0 ? ` after ${formatElapsed(x.elapsedMs)}` : "";
   const fate = pane.closed ? "Pane closed." : `Pane kept (${pane.why}).`;
   const look = [
     x.attach ? `Attach: ${x.attach}` : void 0,
-    `Read: mu agent read ${name} -n 50 -w ${W}`
+    `Read: mu agent read ${name} -n 50 -w ${W2}`
   ].filter((v) => v !== void 0);
   const tailBlock = x.tail?.trim() ? `
 
@@ -185,7 +353,7 @@ ${agent.lastText ?? ""}`;
         "Decide: re-issue the call, or record the check as UNVERIFIED.",
         ...ev,
         ...look,
-        `Close: mu agent close ${name} -w ${W}`
+        `Close: mu agent close ${name} -w ${W2}`
       ].join("\n");
     case "died":
       return `${who} died${took} before answering. ${fate}${ws}${evBlock}${tailBlock}`;
@@ -197,8 +365,8 @@ ${agent.lastText ?? ""}`;
         "Answer the dialog in its pane (attach), then wait again; or close it and record the check as UNVERIFIED.",
         ...ev,
         ...look,
-        `Wait again: mu agent wait ${name} -w ${W} --json${agent.afterRuns !== void 0 ? ` --after-runs ${agent.afterRuns}` : ""}`,
-        `Close: mu agent close ${name} -w ${W}`
+        `Wait again: mu agent wait ${name} -w ${W2} --json${agent.afterRuns !== void 0 ? ` --after-runs ${agent.afterRuns}` : ""}`,
+        `Close: mu agent close ${name} -w ${W2}`
       ];
       return `${lines.join("\n")}${tailBlock}`;
     }
@@ -208,86 +376,195 @@ ${agent.lastText ?? ""}`;
         `${who} is still running after ${timeoutS}s; stopped waiting, so its answer will not arrive here. ${fate}${ws}`,
         ...ev,
         ...look,
-        `Wait again: mu agent wait ${name} -w ${W} --json${agent.afterRuns !== void 0 ? ` --after-runs ${agent.afterRuns}` : ""}`
+        `Wait again: mu agent wait ${name} -w ${W2} --json${agent.afterRuns !== void 0 ? ` --after-runs ${agent.afterRuns}` : ""}`
       ].join("\n");
     default:
       return `${who}: mu agent wait gave no result. ${fate}${ws}${evBlock}${tailBlock}`;
   }
 }
-function droppedAnswersDir() {
-  return join2(defaultCacheDir(), "delegate-answers");
+function answerLine(a) {
+  const how = [a.outcome, a.verdict, a.record ? `recorded on ${a.record}` : void 0].filter((x) => x !== void 0).join(", ");
+  const pane = a.kept ? ` Pane kept (${a.kept}): mu agent read ${a.name} -n 50 -w ${a.workstream}.` : "";
+  return `- ${a.workstream}/${a.name} (${how}; call ${a.callId}): mu task notes ${a.task} -w ${a.workstream}.${pane}`;
+}
+function wakeText(answers) {
+  const n = answers.length;
+  return [
+    `${n === 1 ? "A delegate answer is" : `${n} delegate answers are`} recorded; the settle shows ${n === 1 ? "it" : "them"} (or read the report):`,
+    ...answers.map(answerLine)
+  ].join("\n");
 }
 function droppedNote(dropped) {
   const n = dropped.length;
-  const lines = dropped.map((d) => {
-    const how = [
-      d.outcome ?? "no result",
-      d.elapsedMs !== void 0 ? formatElapsed(d.elapsedMs) : void 0
-    ].filter((x) => x !== void 0).join(", ");
-    const where = [
-      d.copy ? `answer: ${d.copy}` : void 0,
-      d.sessionFile ? `session: ${d.sessionFile}` : void 0
-    ].filter((x) => x !== void 0);
-    if (where.length === 0) where.push(`read: mu agent read ${d.name} -n 50 -w ${W}`);
-    return `- ${W}/${d.name} (${how}) ${where.join(" \xB7 ")}`;
-  });
   return [
-    `The interrupt dropped ${n} delegate answer${n === 1 ? "" : "s"} before ${n === 1 ? "it" : "they"} arrived:`,
-    ...lines,
-    "The answer file holds the message that would have arrived; in a session file the answer is the last assistant message."
+    `Interrupted: ${n} delegate answer${n === 1 ? "" : "s"} recorded but not shown; the next settle shows ${n === 1 ? "it" : "them"}:`,
+    ...dropped.map(answerLine)
   ].join("\n");
 }
-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;
+
+// extension/delegate-process-format.ts
+function processStarted(call2, cancelTool) {
+  const ws = call2.workstream;
+  const name = call2.task;
+  const text = [
+    `Delegated to ${ws}/${name} (call ${call2.callId}) as a child pi process: no multiplexer, so no pane to attach. Its answer arrives with your next settle (and stays on the task: mu task notes ${call2.task} -w ${ws}); carry on, or end your turn if your next step needs it. Do not poll.`,
+    call2.request.keep === true ? "keep: true needs a multiplexer; the child stops after its answer (its session file stays)." : void 0,
+    `Cancel: ${cancelTool} { name: "${name}" }`
+  ].filter((x) => x !== void 0);
+  return {
+    content: [{ type: "text", text: text.join("\n") }],
+    details: {
+      name,
+      workstream: ws,
+      task: `${ws}/${call2.task}`,
+      state: "running",
+      call_id: call2.callId,
+      transport: "process",
+      attach: null,
+      workspace: null,
+      keep: false
+    }
+  };
 }
-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 processFailedText(call2, o, fallback, code, reissueTool) {
+  const reason2 = (o.error ?? o.message ?? fallback).replace(/[.\s]+$/, "");
+  const next = o.state === "refused" ? `The call is durable and refused: reissue it with ${reissueTool} { call_id: "${call2.callId}" }` : `\`mu delegates run\` exited ${code} without a result; the call is recorded as failed (mu delegates show ${call2.callId})`;
+  return `${reason2}. ${next} (task ${call2.workstream}/${call2.task}).`;
 }
-var MODEL_BARE_RE = /^[A-Za-z0-9._:/@+=-]+$/;
-function normalizeModel(raw) {
-  if (typeof raw !== "string") return void 0;
-  let m = raw.trim();
-  for (let prev = ""; prev !== m; ) {
-    prev = m;
-    m = m.replace(/^--model(?:=|\s+)/, "").replace(/^(["'`])(.*)\1$/s, "$2").trim();
+
+// extension/delegate-trace.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { join as join2 } from "path";
+
+// src/state-dir.ts
+import { homedir } from "os";
+import { isAbsolute, join } from "path";
+function defaultCacheDir() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  return join(xdg !== void 0 && isAbsolute(xdg) ? xdg : join(homedir(), ".cache"), "mu");
+}
+
+// extension/delegate-trace.ts
+function delegateTraceOn(env = process.env) {
+  return !!env.MU_DELEGATE_TRACE && env.MU_DELEGATE_TRACE !== "0";
+}
+function delegateTracePath() {
+  return join2(defaultCacheDir(), "delegate-trace.log");
+}
+function trace(event, data = {}) {
+  if (!delegateTraceOn()) return;
+  try {
+    mkdirSync(defaultCacheDir(), { recursive: true });
+    const line = { t: (/* @__PURE__ */ new Date()).toISOString(), pid: process.pid, event, ...data };
+    appendFileSync(delegateTracePath(), `${JSON.stringify(line)}
+`);
+  } catch {
   }
-  return m && !/\s/.test(m) ? m : void 0;
 }
-function shellArg(s) {
-  return MODEL_BARE_RE.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
+var TRACE_EVENTS = [
+  "session_start",
+  "session_before_switch",
+  "session_before_fork",
+  "session_before_compact",
+  "session_compact",
+  "session_compact_failed",
+  "session_before_tree",
+  "session_tree",
+  "agent_start",
+  "agent_end",
+  "agent_settled",
+  "turn_end",
+  "message_start",
+  "message_end"
+];
+function traceFields(event, ctx) {
+  const e = event ?? {};
+  const m = e.message;
+  const d = m?.details;
+  const out = {};
+  if (m?.role) out.role = m.role;
+  if (m?.customType) out.customType = m.customType;
+  if (d?.delivery !== void 0) out.delivery = d.delivery;
+  if (d?.name !== void 0) out.name = d.name;
+  for (const k of ["aborted", "reason", "willRetry"]) if (e[k] !== void 0) out[k] = e[k];
+  try {
+    if (ctx?.isIdle) out.idle = ctx.isIdle();
+    if (ctx?.hasPendingMessages) out.pendingMsgs = ctx.hasPendingMessages();
+  } catch {
+    out.ctx = "stale";
+  }
+  return out;
 }
-function modelCommand(cli, model, env = process.env) {
-  const override = env[`MU_${cli.toUpperCase().replace(/-/g, "_")}_COMMAND`];
-  const base = override && override.trim() !== "" ? override.trim() : cli;
-  return `${base} --model ${shellArg(model)}`;
+
+// extension/delegate.ts
+var DELEGATE_TOOL = "mu_delegate";
+var DELEGATE_CANCEL_TOOL = "mu_delegate_cancel";
+var DELEGATE_REISSUE_TOOL = "mu_delegate_reissue";
+var DELEGATE_MESSAGE_TYPE = "mu-delegate";
+var PENDING_CHANNEL = "murmur:pending";
+var DELEGATE_MAX_DEFAULT = 16;
+var DELEGATE_QUEUE_FACTOR = 4;
+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;
+  return env.MU_DELEGATE !== "0";
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function piSessionId(ctx) {
+  try {
+    const sm = ctx?.sessionManager;
+    return sm?.getSessionId?.();
+  } catch {
+    return void 0;
+  }
 }
 function registerDelegate(pi, run = defaultRunner()) {
-  if (!delegateEnabled()) return { answerPending: () => false };
+  if (!delegateEnabled()) return { answerPending: () => false, delivered: () => {
+  } };
+  if (delegateTraceOn())
+    for (const ev of TRACE_EVENTS)
+      pi.on(ev, (e, ctx) => {
+        trace(ev, traceFields(e, ctx));
+      });
+  const send = (message, options, why2) => {
+    const d = message.details;
+    const a = typeof d?.wake === "number" ? arriving.get(d.wake) : void 0;
+    if (a && options) {
+      options = { ...options };
+      a.message = message;
+      a.opts = [...a.opts ?? [], options];
+    }
+    const at = { why: why2, wake: d?.wake, calls: d?.calls, ...options };
+    trace("sendMessage", { ...at, arriving: arriving.size });
+    try {
+      const r = pi.sendMessage(message, options);
+      trace("sendMessage.returned", { ...at, async: r !== void 0 });
+      return r;
+    } catch (e) {
+      trace("sendMessage.threw", { ...at, error: String(e) });
+      throw e;
+    }
+  };
   const inflight = /* @__PURE__ */ new Map();
   let starting = 0;
   const queue = [];
   let queueSeq = 0;
-  const failed = /* @__PURE__ */ new Set();
-  let lastPruneAt = 0;
+  const owed = /* @__PURE__ */ new Map();
   const arriving = /* @__PURE__ */ new Map();
-  let deliverySeq = 0;
-  let ui;
+  let wakeSeq = 0;
+  let busy = false;
+  let settleCheck;
+  let closed = false;
   let lastPending = 0;
   const reportPending = () => {
     const count = inflight.size + starting + queue.length;
@@ -298,346 +575,448 @@ function registerDelegate(pi, run = defaultRunner()) {
     } catch {
     }
   };
-  const showStatus = () => {
-    reportPending();
-    try {
-      ui?.setStatus?.(
-        DELEGATE_STATUS_KEY,
-        delegateStatus(inflight.size, starting, queue.length, failed.size, arriving.size)
-      );
-    } catch {
-    }
-  };
-  const track = (ctx) => {
-    if (ctx?.hasUI !== false && ctx?.ui) ui = ctx.ui;
-  };
-  const markQueued = (delivery) => {
-    const a = arriving.get(delivery);
-    if (a) a.queued = true;
-  };
-  const saveCopy = (name, content, kind = "") => {
-    try {
-      const dir = droppedAnswersDir();
-      mkdirSync(dir, { recursive: true });
-      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const path = join2(dir, `${stamp}_${name}${kind}.md`);
-      writeFileSync(path, `${content}
-`);
-      return path;
-    } catch {
-      return void 0;
-    }
+  const wake = (why2) => {
+    const covered = new Set([...arriving.values()].flatMap((a) => a.calls));
+    const due = [...owed.values()].filter((a) => !covered.has(a.callId));
+    if (due.length === 0 || closed) return;
+    const id = ++wakeSeq;
+    const ids = due.map((a) => a.callId);
+    arriving.set(id, { sent: false, calls: ids });
+    void Promise.resolve(
+      send(
+        {
+          customType: DELEGATE_MESSAGE_TYPE,
+          content: wakeText(due),
+          display: true,
+          details: { wake: id, calls: ids }
+        },
+        { deliverAs: "followUp", triggerTurn: true },
+        why2
+      )
+    ).then(
+      () => {
+        const a = arriving.get(id);
+        if (a) a.sent = true;
+      },
+      () => arriving.delete(id)
+      // nothing will arrive; the next settle looks again
+    );
   };
-  const partialCopy = (name, sessionFile) => {
-    const text = lastAssistantTextIn(sessionFile);
-    return text ? saveCopy(name, text, ".partial") : void 0;
+  let wakeSoon;
+  const wakeIfIdle = () => {
+    if (wakeSoon !== void 0) return;
+    wakeSoon = setImmediate(() => {
+      wakeSoon = void 0;
+      if (!busy) wake("wake");
+    });
   };
-  const forget = (name) => {
-    inflight.delete(name);
+  const calls = callsApi(run);
+  const token = randomBytes(3).toString("hex");
+  let callSeq = 0;
+  const inflightKey = (ws, name) => `${ws}/${name}`;
+  const forget = (key) => {
+    inflight.delete(key);
     drain();
-    showStatus();
+    reportPending();
   };
+  const startFailed = (handle, e, what = "Queued delegate") => void Promise.resolve(
+    send(
+      {
+        customType: DELEGATE_MESSAGE_TYPE,
+        content: `${what} ${handle} could not start: ${e instanceof Error ? e.message : String(e)}`,
+        display: true,
+        details: { name: handle, workstream: W, outcome: null, closed: false }
+      },
+      { deliverAs: "followUp", triggerTurn: true },
+      "start-failed"
+    )
+  ).catch(() => {
+  });
   function drain() {
     while (queue.length > 0 && inflight.size + starting < delegateMax()) {
       const q = queue.shift();
       if (!q) break;
       starting++;
-      void start(q.params, void 0, q.ctx, q.handle, q.record).then(
+      void q.registered.then(async () => {
+        try {
+          await calls.mark(q.call.callId, "starting");
+        } catch (e) {
+          starting--;
+          reportPending();
+          throw e;
+        }
+        return start(q.call, void 0, q.ctx, q.handle);
+      }).then(
         () => {
         },
         (e) => {
-          void Promise.resolve(
-            pi.sendMessage(
-              {
-                customType: DELEGATE_MESSAGE_TYPE,
-                content: `Queued delegate ${q.handle} could not start: ${e instanceof Error ? e.message : String(e)}`,
-                display: true,
-                details: { name: q.handle, workstream: W, outcome: null, closed: false }
-              },
-              { deliverAs: "followUp", triggerTurn: true }
-            )
-          ).catch(() => {
-          });
+          startFailed(q.handle, e);
+          drain();
         }
       );
     }
   }
   const mu = run;
-  const json = (r) => {
-    try {
-      const v = JSON.parse(r.stdout);
-      return typeof v === "object" && v !== null ? v : void 0;
-    } catch {
-      return void 0;
-    }
+  const json = (r) => parseEnvelope(r.stdout);
+  const why = (r) => {
+    const m = json(r)?.message;
+    return (typeof m === "string" ? m : r.stderr || r.stdout).trim();
   };
-  const failure = (what, r) => new Error(`${what} failed (exit ${r.code}): ${(r.stderr || r.stdout).trim()}`);
-  function pruneFailed() {
-    if (failed.size === 0) return;
-    const now = Date.now();
-    if (now - lastPruneAt < PRUNE_FAILED_MS) return;
-    lastPruneAt = now;
-    void mu(["agent", "list", "-w", W, "--json"]).then((r) => {
-      const agents = json(r)?.agents;
-      if (!Array.isArray(agents)) return;
-      const taken = new Set(agents.map((a) => a.name));
-      for (const f of [...failed]) if (!taken.has(f)) failed.delete(f);
-      showStatus();
-    });
+  const failure = (what, r) => new Error(`${what} failed (exit ${r.code}): ${why(r)}`);
+  const errText = (e) => e instanceof Error ? e.message : String(e);
+  async function closeDelegate(name, id, W2) {
+    if (id === void 0) return { closed: false, why: "its spawn did not report an identity" };
+    const p = await mu(["agent", "close", name, "-w", W2, "--json"]);
+    const d = p.code === 0 ? parseOkEnvelope(p.stdout) : void 0;
+    if (d === void 0) return { closed: false, why: `close preview failed: ${why(p)}` };
+    if (d.kind === "none") return { closed: false, why: "it is no longer registered" };
+    if (d.kind !== "agent" || d.id !== id.incarnation || d.pane_id !== id.paneId)
+      return { closed: false, why: "the name now belongs to another agent" };
+    if (!Number.isSafeInteger(d.revision))
+      return { closed: false, why: "close preview had no revision" };
+    const c = await mu(["agent", "close", name, "-w", W2, "--if", String(d.revision), "--json"]);
+    return c.code === 0 ? { closed: true } : { closed: false, why: `close refused: ${why(c)}` };
+  }
+  class SpawnFail extends Error {
+    constructor(message, kind) {
+      super(message);
+      this.kind = kind;
+    }
+    kind;
   }
-  async function spawn(params, text, cwd, signal) {
-    signal?.throwIfAborted();
-    pruneFailed();
-    const stem = labelStem(params.label);
+  async function spawn(call2, text, cwd, signal) {
+    if (signal?.aborted) throw new SpawnFail("cancelled before it spawned", "aborted");
+    const ws = call2.workstream;
+    const req = call2.request;
+    const stem = labelStem(req.label);
     const base = stem ? `delegate-${stem}` : "delegate-1";
-    const args = ["agent", "spawn", base, "-w", W, "--next-free", "--send", text, "--json"];
-    if (params.workspace === true) args.push("--workspace");
+    const args = [
+      "agent",
+      "spawn",
+      base,
+      "-w",
+      ws,
+      "--next-free",
+      "--task",
+      call2.task,
+      "--attempt",
+      call2.task,
+      "--send",
+      text,
+      "--json"
+    ];
+    if (req.workspace === true) args.push("--worktree", ...req.cwd ? ["--root", req.cwd] : []);
     else if (cwd) args.push("--cwd", cwd);
-    const cli = typeof params.cli === "string" && params.cli ? params.cli : void 0;
+    const cli = req.cli ? req.cli : void 0;
     if (cli) args.push("--cli", cli);
-    if (typeof params.model === "string" && params.model)
-      args.push("--command", modelCommand(cli ?? "pi", params.model));
-    const r = await mu(args);
+    if (req.model) args.push("--command", modelCommand(cli ?? "pi", req.model));
+    const r = await mu(args, signal);
     const out = json(r);
+    const stale = out?.task?.stale;
+    if (typeof stale === "string")
+      throw new SpawnFail(
+        `the attempt of ${ws}/${call2.task} is stale: its agent was ${stale}; the replacement was left alone`,
+        "unsent"
+      );
     const spawned = out?.agent?.name;
-    if (typeof spawned !== "string") throw failure("mu agent spawn", r);
+    if (typeof spawned !== "string" && out?.error === "NoMultiplexerError")
+      throw new SpawnFail("no multiplexer", "nomux");
+    if (typeof spawned !== "string" && signal?.aborted)
+      throw new SpawnFail("cancelled while it spawned; the spawn rolled back", "aborted");
+    if (typeof spawned !== "string") {
+      const msg = failure("mu agent spawn", r).message;
+      if (out?.error === "WorktreeVcsRequiredError")
+        throw new SpawnFail(`${msg}. Pass cwd: <a git repo>`, "refused");
+      throw new SpawnFail(msg, out?.error === "UsageError" ? "refused" : "unsent");
+    }
     const name = spawned;
+    const row = out?.agent;
+    const identity = typeof row?.pane_id === "string" && Number.isSafeInteger(row.id) ? { paneId: row.pane_id, incarnation: row.id } : void 0;
     if (signal?.aborted) {
-      await mu(["agent", "close", name, "-w", W]);
-      signal.throwIfAborted();
+      await closeDelegate(name, identity, ws);
+      throw new SpawnFail("cancelled while it spawned", "aborted");
     }
-    if (out?.ctl !== "ok") {
-      throw new Error(
-        `${W}/${name} spawned but its control socket is ${String(out?.ctl)}, so its answer cannot come back. Pane kept; close it with: mu agent close ${name} -w ${W}`
+    if (out?.ctl !== void 0 && out.ctl !== "ok") {
+      throw new SpawnFail(
+        `${ws}/${name} spawned but its control socket is ${String(out.ctl)}, so its answer cannot come back. Pane kept; close it with: mu agent close ${name} -w ${ws}`,
+        "kept"
       );
     }
-    const sent = out.send;
+    const sent = out?.send;
     if (sent?.ok !== true && sent?.error === "AgentSendIndeterminateError") {
-      const why = typeof sent.message === "string" ? sent.message : "no reply";
-      throw new Error(
-        `mu agent send to ${W}/${name}: delivery unknown (${why}). Pane kept; do NOT resend blindly. Check with: mu agent read ${name} -w ${W} -n 20 (or attach), then close it with: mu agent close ${name} -w ${W}`
+      const reason2 = typeof sent.message === "string" ? sent.message : "no reply";
+      throw new SpawnFail(
+        `mu agent send to ${ws}/${name}: delivery unknown (${reason2}). Pane kept; do NOT resend blindly. Check with: mu agent read ${name} -w ${ws} -n 20 (or attach), then close it with: mu agent close ${name} -w ${ws}`,
+        "unknown"
       );
     }
     if (sent?.ok !== true) {
-      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}`;
-      const why = typeof sent?.message === "string" ? sent.message : (r.stderr || r.stdout).trim();
-      throw new Error(`mu agent send to ${W}/${name} failed (exit ${r.code}): ${why}. ${pane}`);
+      const c = await closeDelegate(name, identity, ws);
+      const pane = c.closed ? "Pane closed." : `Pane kept (${c.why}); close it with: mu agent close ${name} -w ${ws}`;
+      const reason2 = typeof sent?.message === "string" ? sent.message : why(r);
+      throw new SpawnFail(
+        `mu agent send to ${ws}/${name} failed (exit ${r.code}): ${reason2}. ${pane}`,
+        "unsent"
+      );
     }
-    const steps = Array.isArray(out.nextSteps) ? out.nextSteps : [];
-    const attach = steps.map((s) => s).find((s) => s.intent === "Attach the pane")?.command;
-    const wsPath = out.workspace?.path;
+    const attach = out?.attach;
+    const wsPath = req.workspace === true ? row?.cwd : void 0;
     return {
       name,
       // A pi just spawned has settled no run, so 0 is exact when an older
       // extension's reply carries no runs.
       runs: typeof sent.runs === "number" ? sent.runs : 0,
+      ...identity ? { identity } : {},
       ...typeof attach === "string" ? { attach } : {},
       ...typeof wsPath === "string" ? { workspace: wsPath } : {},
       ...typeof sent.sessionFile === "string" ? { sessionFile: sent.sessionFile } : {}
     };
   }
-  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 task = typeof r?.task === "string" ? r.task : "";
+    if (task.trim() === "") throw new Error("mu_delegate: record.task must name a task");
+    const scope = (value, what) => {
+      const problem = workstreamNameProblem(value, what);
+      if (problem !== void 0) throw new Error(`mu_delegate: ${problem} Nothing spawned.`);
+      return value;
+    };
+    const rawWs = r?.workstream;
+    const ws = rawWs === void 0 || rawWs === null ? "" : scope(typeof rawWs === "string" ? rawWs : String(rawWs), "record.workstream");
+    const slash = task.indexOf("/");
+    if (slash >= 0) {
+      const refProblem = qualifiedRefProblem(task);
+      if (refProblem !== void 0) throw new Error(`mu_delegate: ${refProblem} Nothing spawned.`);
+      const prefix = task.slice(0, slash);
+      if (ws && ws !== prefix) {
+        throw new Error(
+          `mu_delegate: record.task ${task} conflicts with record.workstream ${ws}. Nothing spawned.`
+        );
+      }
+    }
+    if (task !== task.trim()) {
+      throw new Error(
+        `mu_delegate: record.task ${JSON.stringify(task)} has surrounding whitespace. Nothing spawned.`
+      );
+    }
+    if (!ws && slash < 0) {
+      throw new Error(
+        `mu_delegate: record.task ${task} needs a workstream: pass record.task as <workstream>/${task}, or set record.workstream. Nothing spawned.`
+      );
+    }
     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();
+    if (shown.code !== 0 || typeof t?.id !== "string" || typeof t.workstream !== "string") {
       throw new Error(
-        `mu_delegate: record task ${ws ? `${ws}/` : ""}${task} not found (exit ${shown.code}): ${why}. Nothing spawned.`
+        `mu_delegate: record task ${ws ? `${ws}/` : ""}${task} not found (exit ${shown.code}): ${why(shown)}. Nothing spawned.`
       );
     }
-    return { workstream: t.workstreamName, task: t.name };
+    return { workstream: t.workstream, task: t.id };
   }
-  async function writeRecord(rec, name, text) {
-    const where = `${rec.workstream}/${rec.task}`;
+  const recordedLine = (call2, err) => `Recording failed: ${err}. The call ${call2.callId} is still open; its answer is in this message. Record it yourself.`;
+  async function deliver(call2, name, wait, keep, extras, identity) {
+    const ws = call2.workstream;
+    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", ws])).stdout;
+    const sessionFile = agent?.sessionFile ?? extras.sessionFile;
+    const x = {
+      ...extras,
+      workstream: ws,
+      ...sessionFile ? { sessionFile } : {},
+      ...tail ? { tail } : {}
+    };
+    const partial = outcome !== "done" && outcome !== "blocked" && sessionFile ? lastAssistantTextIn(sessionFile) : void 0;
+    const kept = {
+      closed: false,
+      why: outcome === "blocked" ? "waiting on a dialog" : "kept as evidence"
+    };
+    const gap = () => [
+      delegateMessage(
+        name,
+        agent,
+        outcome === "empty" ? { closed: !keep } : kept,
+        x
+      ),
+      partial ? `Partial answer so far:
+${partial}` : void 0
+    ].filter((v) => v !== void 0).join("\n\n");
+    let fin;
+    let finErr = "unknown error";
     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.`;
+      fin = await calls.finish(call2.callId, {
+        outcome: outcome ?? "no result",
+        text: outcome === "done" ? agent?.lastText ?? "" : gap(),
+        ...extras.elapsedMs !== void 0 ? { elapsedMs: extras.elapsedMs } : {},
+        author: name
+      });
     } catch (e) {
-      return `Recording on ${where} failed: ${e instanceof Error ? e.message : String(e)}. Record it yourself.`;
+      finErr = errText(e);
     }
-  }
-  async function deliver(name, wait, keep, extras, delivery, 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;
     let pane = { closed: false, why: "keep: true" };
-    let closing;
-    if (outcome === "blocked") pane = { closed: false, why: "waiting on a dialog" };
-    else if (outcome !== "done" && outcome !== "empty")
-      pane = { closed: false, why: "kept as evidence" };
-    else if (!keep) closing = mu(["agent", "close", name, "-w", W]);
-    const recording = record ? writeRecord(
-      record.target,
-      name,
-      recordNote(record.label, name, outcome, agent?.lastText, extras.elapsedMs ?? 0)
-    ) : void 0;
-    const [closed, recorded] = await Promise.all([closing, recording]);
-    if (closed)
-      pane = closed.code === 0 ? { closed: true } : { closed: false, why: `close refused: ${(closed.stderr || closed.stdout).trim()}` };
-    if (outcome === "error" && !pane.closed) {
-      failed.add(name);
-      showStatus();
-    }
-    if (outcome !== "done") {
-      const sessionFile = agent?.sessionFile ?? extras.sessionFile;
-      const partial = sessionFile && outcome !== "blocked" ? partialCopy(name, sessionFile) : void 0;
-      extras = {
-        ...extras,
-        ...sessionFile ? { sessionFile } : {},
-        ...partial ? { partial } : {}
-      };
-    }
-    const message = delegateMessage(name, agent, pane, { ...extras, ...tail ? { tail } : {} });
-    const content = recorded ? `${message}
+    if (outcome === "blocked") pane = kept;
+    else if (outcome !== "done" && outcome !== "empty") pane = kept;
+    else if (fin?.state !== "done" && outcome === "done")
+      pane = { closed: false, why: "its result is not recorded" };
+    else if (!keep) pane = await closeDelegate(name, identity, ws);
+    if (fin === void 0) {
+      await send(
+        {
+          customType: DELEGATE_MESSAGE_TYPE,
+          content: `${delegateMessage(name, agent, pane, x)}
 
-${recorded}` : message;
-    const a = arriving.get(delivery);
-    if (a)
-      Object.assign(a, {
-        content,
-        ...outcome ? { outcome } : {},
-        ...extras.elapsedMs !== void 0 ? { elapsedMs: extras.elapsedMs } : {},
-        ...agent?.sessionFile ? { sessionFile: agent.sessionFile } : {}
-      });
-    await pi.sendMessage(
-      {
-        customType: DELEGATE_MESSAGE_TYPE,
-        content,
-        display: true,
-        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,
-          sessionFile: agent?.sessionFile ?? extras.sessionFile ?? null,
-          partial: extras.partial ?? null,
-          delivery
-        }
-      },
-      { deliverAs: "followUp", triggerTurn: true }
+${recordedLine(call2, finErr)}`,
+          display: true,
+          details: { name, workstream: ws, call_id: call2.callId, outcome: outcome ?? null }
+        },
+        { deliverAs: "followUp", triggerTurn: true },
+        "unrecorded"
+      );
+      return;
+    }
+    owed.set(call2.callId, {
+      callId: call2.callId,
+      name,
+      workstream: ws,
+      task: call2.task,
+      // A failed record says so (the answer is kept as the report): record it yourself.
+      outcome: fin.state === "failed" && fin.error ? `${outcome ?? "no result"}, NOT recorded: ${fin.error}` : outcome ?? "no result",
+      ...fin.verdict ? { verdict: fin.verdict } : {},
+      ...call2.record && fin.recorded ? { record: `${call2.record.workstream}/${call2.record.task}` } : {},
+      ...pane.closed ? {} : { kept: pane.why },
+      at: Date.now()
+    });
+    wakeIfIdle();
+  }
+  async function watch(call2, name, runs, o) {
+    const ws = call2.workstream;
+    const key = inflightKey(ws, name);
+    const entry2 = {
+      abort: new AbortController(),
+      call: call2,
+      cancelling: false,
+      ...o.sessionFile ? { sessionFile: o.sessionFile } : {},
+      ...o.identity ? { identity: o.identity } : {}
+    };
+    inflight.set(key, entry2);
+    if (o.tracked === void 0) reportPending();
+    await o.tracked?.();
+    const started = o.startedAt ?? Date.now();
+    const left = Math.max(1, Math.ceil(o.timeoutS - (Date.now() - started) / 1e3));
+    const waiting = mu(
+      [
+        "agent",
+        "wait",
+        name,
+        "-w",
+        ws,
+        "--json",
+        "--timeout",
+        String(left),
+        "--after-runs",
+        String(runs)
+      ],
+      entry2.abort.signal
     );
+    const settle = async (r) => {
+      trace("settle", { call: call2.callId, name, code: r.code });
+      forget(key);
+      try {
+        await deliver(
+          call2,
+          name,
+          r,
+          o.keep,
+          {
+            timeoutS: o.timeoutS,
+            elapsedMs: Date.now() - started,
+            ...o.queuedAs ? { queuedAs: o.queuedAs } : {},
+            ...o.attach ? { attach: o.attach } : {},
+            ...o.workspace ? { workspace: o.workspace } : {},
+            ...entry2.sessionFile ? { sessionFile: entry2.sessionFile } : {}
+          },
+          entry2.identity
+        );
+      } catch (e) {
+        const content = `Delegate ${ws}/${name} settled, but delivering its answer failed: ${e instanceof Error ? e.message : String(e)}. Read it with: mu agent read ${name} -n 50 -w ${ws}`;
+        await Promise.resolve(
+          send(
+            {
+              customType: DELEGATE_MESSAGE_TYPE,
+              content,
+              display: true,
+              details: { name, workstream: ws, outcome: null, closed: false }
+            },
+            { deliverAs: "followUp", triggerTurn: true },
+            "deliver-failed"
+          )
+        ).catch(() => {
+        });
+      }
+    };
+    void waiting.then(async (r) => {
+      if (inflight.get(key) !== entry2) return;
+      if (entry2.cancelling) entry2.parked = () => settle(r);
+      else await settle(r);
+    });
+    return entry2;
   }
-  async function start(params, signal, ctx, queuedAs, record) {
+  async function start(call2, signal, ctx, queuedAs) {
     let slotHeld = true;
     const freeSlot = () => {
       if (slotHeld) {
         starting--;
-        showStatus();
+        reportPending();
       }
       slotHeld = false;
     };
-    showStatus();
+    reportPending();
+    const ws = call2.workstream;
+    const req = call2.request;
     try {
-      const task = typeof params.task === "string" ? params.task.trim() : "";
-      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 keep = req.keep === true;
+      const timeoutS = req.timeoutS ?? DELEGATE_TIMEOUT_S;
+      let cwd;
+      if (req.workspace !== true) {
+        cwd = req.cwd ? req.cwd : ctx?.cwd ?? process.cwd();
+        if (!isDir(cwd))
+          throw new SpawnFail(`mu_delegate: cwd ${cwd} is not a directory`, "unsent");
+      }
+      let spawned;
+      try {
+        spawned = await spawn(call2, req.text, cwd, signal);
+      } catch (e) {
+        if (e instanceof SpawnFail && e.kind === "nomux") {
+          freeSlot();
+          return startProcess(call2);
+        }
+        const fail2 = e instanceof SpawnFail ? e : new SpawnFail(errText(e), "unsent");
+        await settleFailedStart(call2, fail2);
         throw new Error(
-          `mu_delegate: timeout must be a positive number of seconds (got ${JSON.stringify(t)})`
+          fail2.kind === "unsent" ? `${fail2.message}. The call is durable and refused: reissue it with ${DELEGATE_REISSUE_TOOL} { call_id: "${call2.callId}" } (task ${ws}/${call2.task}).` : `${fail2.message}. Recorded on ${ws}/${call2.task} as failed.`
         );
-      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, runs, attach, workspace, sessionFile } = await spawn(
-        params,
-        brief ? `${brief}
-
-${task}` : task,
-        cwd,
-        signal
-      );
-      const entry = {
-        abort: new AbortController(),
-        cancelling: false,
+      const { name, runs, attach, workspace, sessionFile, identity } = spawned;
+      await watch(call2, name, runs, {
+        keep,
+        timeoutS,
+        ...queuedAs ? { queuedAs } : {},
+        ...attach ? { attach } : {},
+        ...workspace ? { workspace } : {},
         ...sessionFile ? { sessionFile } : {},
-        ...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),
-          "--after-runs",
-          String(runs)
-        ],
-        entry.abort.signal
-      );
-      const settle = async (r) => {
-        const delivery = ++deliverySeq;
-        arriving.set(delivery, { queued: false, name });
-        forget(name);
-        try {
-          await deliver(
-            name,
-            r,
-            keep,
-            {
-              timeoutS,
-              elapsedMs: Date.now() - started,
-              ...queuedAs ? { queuedAs } : {},
-              ...attach ? { attach } : {},
-              ...workspace ? { workspace } : {},
-              ...entry.sessionFile ? { sessionFile: entry.sessionFile } : {}
-            },
-            delivery,
-            entry.record
-          );
-          markQueued(delivery);
-        } catch (e) {
-          const 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}`;
-          const a = arriving.get(delivery);
-          if (a) a.content = content;
-          await Promise.resolve(
-            pi.sendMessage(
-              {
-                customType: DELEGATE_MESSAGE_TYPE,
-                content,
-                display: true,
-                details: { name, workstream: W, outcome: null, closed: false, delivery }
-              },
-              { deliverAs: "followUp", triggerTurn: true }
-            )
-          ).then(
-            () => markQueued(delivery),
-            () => {
-              arriving.delete(delivery);
-              showStatus();
-            }
-          );
+        ...identity ? { identity } : {},
+        tracked: async () => {
+          freeSlot();
+          reportPending();
+          await calls.mark(call2.callId, "running", { agent: name }).catch((e) => {
+            trace("mark.running.failed", { call: call2.callId, error: errText(e) });
+          });
         }
-      };
-      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.`,
+        `Delegated to ${ws}/${name} (task ${ws}/${call2.task}, call ${call2.callId}). Its answer arrives with your next settle (and stays on the task: mu task notes ${call2.task} -w ${ws}); carry on, or end your turn if your next step needs it. Do not poll.`,
         workspace ? `Workspace: ${workspace}` : void 0,
         attach ? `Attach: ${attach}` : void 0,
         `Cancel: ${DELEGATE_CANCEL_TOOL} { name: "${name}" }`
@@ -646,7 +1025,10 @@ ${task}` : task,
         content: [{ type: "text", text: lines.join("\n") }],
         details: {
           name,
-          workstream: W,
+          workstream: ws,
+          task: `${ws}/${call2.task}`,
+          state: "running",
+          call_id: call2.callId,
           attach: attach ?? null,
           workspace: workspace ?? null,
           keep
@@ -657,11 +1039,92 @@ ${task}` : task,
       drain();
     }
   }
+  const finishOrphan = (call2, outcome, text) => calls.finish(call2.callId, { outcome, text, author: call2.caller }).catch((e) => {
+    trace("finishOrphan.failed", { call: call2.callId, error: errText(e) });
+    return void 0;
+  });
+  function startProcess(call2) {
+    const ws = call2.workstream;
+    const name = call2.task;
+    const key = inflightKey(ws, name);
+    const entry2 = { abort: new AbortController(), call: call2, cancelling: false };
+    inflight.set(key, entry2);
+    reportPending();
+    const settle = async (r) => {
+      const o = json(r) ?? {};
+      forget(key);
+      if (o.outcome === void 0 || o.state === "refused") {
+        const text = processFailedText(call2, o, why(r), r.code, DELEGATE_REISSUE_TOOL);
+        if (o.state !== "refused") await finishOrphan(call2, "error", text);
+        startFailed(name, new Error(text), "Delegate");
+        return;
+      }
+      const verdict = await calls.show(call2.callId).then((x) => x.verdict ?? void 0).catch(() => void 0);
+      owed.set(call2.callId, {
+        callId: call2.callId,
+        name,
+        workstream: ws,
+        task: call2.task,
+        outcome: o.outcome,
+        ...verdict ? { verdict } : {},
+        ...call2.record && o.state === "done" ? { record: `${call2.record.workstream}/${call2.record.task}` } : {},
+        at: Date.now()
+      });
+      wakeIfIdle();
+    };
+    const running = mu(
+      ["delegates", "run", call2.callId, "--no-keep", "--json"],
+      entry2.abort.signal,
+      void 0,
+      { drainMs: 2e4 }
+    );
+    entry2.process = running;
+    void running.then(async (r) => {
+      if (inflight.get(key) !== entry2) return;
+      await settle(r);
+    });
+    return processStarted(call2, DELEGATE_CANCEL_TOOL);
+  }
+  async function settleFailedStart(call2, fail2) {
+    try {
+      if (fail2.kind === "unsent") await calls.mark(call2.callId, "refused", { error: fail2.message });
+      else
+        await calls.finish(call2.callId, {
+          outcome: fail2.kind === "aborted" ? "cancelled" : fail2.kind === "unknown" ? "unknown" : "error",
+          text: fail2.message,
+          author: call2.caller
+        });
+    } catch (e) {
+      trace("settleFailedStart.failed", { call: call2.callId, error: errText(e) });
+    }
+  }
+  const callIdIn = (name) => name.startsWith("pi:");
+  const admission = () => {
+    const max = delegateMax();
+    if (inflight.size + starting < max) return "starting";
+    return queue.length < DELEGATE_QUEUE_FACTOR * max ? "queued" : "refused";
+  };
+  const queuedResult = (call2, state, handle, position) => {
+    const max = delegateMax();
+    const taskRef = `${call2.workstream}/${call2.task}`;
+    const text = state === "refused" ? `REFUSED, not started: ${inflight.size + starting} running and ${queue.length} queued (MU_DELEGATE_MAX=${max}). The call is durable (task ${taskRef}, call ${call2.callId}) and will NOT start on its own. Reissue it once slots free, as answers arrive: ${DELEGATE_REISSUE_TOOL} { call_id: "${call2.callId}" }. List: mu delegates.` : `Queued as ${handle} (#${position}; ${inflight.size + starting} running, MU_DELEGATE_MAX=${max}; task ${taskRef}, call ${call2.callId}). It starts when a slot frees, and its answer arrives with a settle like any delegate's; do not poll. Cancel: ${DELEGATE_CANCEL_TOOL} { name: "${handle}" }`;
+    return {
+      content: [{ type: "text", text }],
+      details: {
+        name: handle,
+        workstream: call2.workstream,
+        task: taskRef,
+        state,
+        call_id: call2.callId,
+        ...state === "queued" ? { queued: true, position } : { refused: true }
+      }
+    };
+  };
   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, 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",
+    description: `Subagent: run one self-contained task in a fresh pi agent (its own mux pane in mu's ${W} workstream; with no tmux or herdr, a child pi process with no pane) 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; past that a call is refused: durable, reissue it with ${DELEGATE_REISSUE_TOOL}). Every call is a mu task (kind delegate): the result names it, and the full answer stays on it. 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, with a settle (a wave's as ONE summary): carry on with other work, or end your turn if your next step needs the answer (it resumes you). The pane closes after a clean finish; keep: true leaves it open (needs a mux). When the check judges a mu task, set record so its verdict lands on that task; leave it out when there is no task. Set wave to group a fan-out (mu delegates tally).`,
+    promptSnippet: "Subagent: delegate a self-contained task to a background pi agent; its answer arrives later, with a settle",
     parameters: {
       type: "object",
       properties: {
@@ -676,16 +1139,16 @@ ${task}` : task,
         },
         cwd: {
           type: "string",
-          description: "Working directory for the delegate (default: yours; ignored with workspace)"
+          description: "Working directory for the delegate (default: yours); with workspace, the git repo the worktree is made from"
         },
         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.`
+          description: `Seconds to wait for the answer (default ${DELEGATE_TIMEOUT_S}). On timeout you get a "still running" answer instead, and the real answer will not arrive later; the subagent keeps running in its pane.`
         },
         workspace: {
           type: "boolean",
-          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."
+          description: "For tasks that edit files: its own git worktree branched from the current commit of the repo at cwd (default: yours). The result names 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",
@@ -697,24 +1160,31 @@ ${task}` : task,
         },
         keep: {
           type: "boolean",
-          description: "Keep the pane after it finishes, to talk to it again"
+          description: "Keep the pane after it finishes, to talk to it again (needs a mux; ignored without one)"
         },
         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>.",
+          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); name the workstream: task as <ws>/<task>, or set workstream.",
           properties: {
             task: { type: "string" },
             workstream: { type: "string" }
           },
           required: ["task"],
           additionalProperties: false
+        },
+        wave: {
+          type: "string",
+          description: "Label grouping the calls of one fan-out; `mu delegates tally -w <workstream> --wave <label>` counts their verdicts per judged task."
+        },
+        workstream: {
+          type: "string",
+          description: `Workstream that holds the delegate task and runs the delegate (default: ${W}).`
         }
       },
       required: ["task"],
       additionalProperties: false
     },
     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 t = params.timeout;
@@ -722,179 +1192,437 @@ ${task}` : task,
         throw new Error(
           `mu_delegate: timeout must be a positive number of seconds (got ${JSON.stringify(t)})`
         );
-      if (params.workspace !== true) {
-        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 callCwd = typeof params.cwd === "string" && params.cwd ? params.cwd : params.workspace !== true ? ctx?.cwd ?? process.cwd() : void 0;
+      if (callCwd !== void 0 && !isDir(callCwd))
+        throw new Error(`mu_delegate: cwd ${callCwd} is not a directory`);
+      let model;
+      if (params.model !== void 0 && params.model !== "") {
+        model = normalizeModel(params.model);
+        if (!model)
+          throw new Error(
+            `mu_delegate: model must be one pi model id like 'provider/id:thinking', as listed by \`pi --list-models\` (got ${JSON.stringify(params.model)}); omit it for the cli's default`
+          );
+      }
+      let workstream = W;
+      if (params.workstream !== void 0) {
+        const problem = workstreamNameProblem(
+          typeof params.workstream === "string" ? params.workstream : String(params.workstream),
+          "workstream"
+        );
+        if (problem !== void 0) throw new Error(`mu_delegate: ${problem} Nothing spawned.`);
+        workstream = params.workstream;
+      }
+      if (params.wave !== void 0 && (typeof params.wave !== "string" || params.wave.trim() === ""))
+        throw new Error(
+          `mu_delegate: wave must be a non-empty label (got ${JSON.stringify(params.wave)})`
+        );
+      const record = await resolveRecord(params.record);
+      const brief = typeof params.brief === "string" ? params.brief.trim() : "";
+      const label = typeof params.label === "string" && params.label.trim() ? params.label.trim() : void 0;
+      const decision = admission();
+      const handle = decision === "starting" ? "" : `queued-${++queueSeq}`;
+      if (decision === "starting") starting++;
+      const session = piSessionId(ctx) || process.env.PI_SESSION_ID || `local-${token}`;
+      const caller = `pi:${session}`;
+      const info = {
+        callId: `${caller}:${token}-${++callSeq}`,
+        caller,
+        workstream,
+        ...typeof params.wave === "string" ? { wave: params.wave.trim() } : {},
+        ...record ? { record } : {},
+        request: {
+          text: brief ? `${brief}
+
+${task}` : task,
+          ...label ? { label } : {},
+          ...typeof params.cli === "string" && params.cli ? { cli: params.cli } : {},
+          ...model ? { model } : {},
+          ...callCwd !== void 0 ? { cwd: callCwd } : {},
+          ...params.workspace === true ? { workspace: true } : {},
+          ...typeof t === "number" ? { timeoutS: Math.ceil(t) } : {},
+          ...params.keep === true ? { keep: true } : {}
+        }
+      };
+      if (decision === "starting") {
+        let reg;
+        try {
+          reg = await calls.register(info, "starting");
+        } catch (e) {
+          starting--;
+          reportPending();
+          drain();
+          throw new Error(
+            `mu_delegate: could not register the call: ${errText(e)}. Nothing spawned.`
+          );
+        }
+        return start(reg.call, signal, ctx);
       }
-      if (params.model !== void 0 && params.model !== "") {
-        const m = normalizeModel(params.model);
-        if (!m)
+      if (decision === "refused") {
+        let reg;
+        try {
+          reg = await calls.register(info, "refused");
+        } catch (e) {
           throw new Error(
-            `mu_delegate: model must be one pi model id like 'provider/id:thinking', as listed by \`pi --list-models\` (got ${JSON.stringify(params.model)}); omit it for the cli's default`
+            `mu_delegate: could not register the call: ${errText(e)}. Nothing spawned.`
           );
-        params = { ...params, model: m };
+        }
+        return queuedResult(reg.call, "refused", handle, 0);
       }
-      const record = await resolveRecord(params.record);
-      const max = delegateMax();
-      if (inflight.size + starting < max) {
-        starting++;
-        return start(params, signal, ctx, void 0, record);
+      const entry2 = {
+        handle,
+        call: { ...info, task: "" },
+        ctx,
+        registered: Promise.resolve()
+      };
+      entry2.registered = calls.register(info, "queued").then((reg) => {
+        entry2.call = reg.call;
+      });
+      queue.push(entry2);
+      reportPending();
+      try {
+        await entry2.registered;
+      } catch (e) {
+        const at = queue.indexOf(entry2);
+        if (at >= 0) queue.splice(at, 1);
+        reportPending();
+        throw new Error(`mu_delegate: could not register the call: ${errText(e)}. Nothing queued.`);
       }
-      if (queue.length >= DELEGATE_QUEUE_FACTOR * max)
+      return queuedResult(entry2.call, "queued", handle, queue.indexOf(entry2) + 1 || queue.length);
+    }
+  });
+  pi.registerTool({
+    name: DELEGATE_REISSUE_TOOL,
+    label: "mu delegate reissue",
+    description: `Run a call ${DELEGATE_TOOL} refused (the queue was full): same call, same task, never a second verdict. Takes the call_id from the refusal; starts now if a slot is free, else queues.`,
+    parameters: {
+      type: "object",
+      properties: { call_id: { type: "string", description: "The refused call's id" } },
+      required: ["call_id"],
+      additionalProperties: false
+    },
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      const callId = typeof params.call_id === "string" ? params.call_id : "";
+      if (!callId) throw new Error(`${DELEGATE_REISSUE_TOOL} needs a call_id`);
+      const shown = await calls.show(callId).catch((e) => {
+        throw new Error(`${DELEGATE_REISSUE_TOOL}: ${errText(e)}`);
+      });
+      if (shown.state !== "refused")
+        throw new Error(`${DELEGATE_REISSUE_TOOL}: call ${callId} is ${shown.state}, not refused.`);
+      const decision = admission();
+      if (decision === "refused")
         throw new Error(
-          `mu_delegate: ${inflight.size + starting} running and ${queue.length} queued (MU_DELEGATE_MAX=${max}). End your turn; issue the rest as answers arrive (each answer resumes you).`
+          `${DELEGATE_REISSUE_TOOL}: still full (${inflight.size + starting} running, ${queue.length} queued). Nothing changed; reissue ${callId} when an answer arrives.`
         );
+      if (decision === "starting") starting++;
+      try {
+        await calls.mark(callId, decision === "starting" ? "starting" : "queued");
+      } catch (e) {
+        if (decision === "starting") {
+          starting--;
+          reportPending();
+          drain();
+        }
+        throw new Error(`${DELEGATE_REISSUE_TOOL}: ${errText(e)}`);
+      }
+      if (decision === "starting") return start(shown.call, signal, ctx);
       const handle = `queued-${++queueSeq}`;
-      queue.push({
-        handle,
-        params: {
-          ...params,
-          cwd: typeof params.cwd === "string" && params.cwd ? params.cwd : ctx?.cwd ?? process.cwd()
-        },
-        ctx,
-        ...record ? { record } : {}
-      });
-      showStatus();
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Queued as ${handle} (#${queue.length}; ${inflight.size + starting} running, MU_DELEGATE_MAX=${max}). It starts when a slot frees, and its answer arrives as a follow-up message like any delegate's; do not wait or poll. Cancel: ${DELEGATE_CANCEL_TOOL} { name: "${handle}" }`
-          }
-        ],
-        details: { name: handle, workstream: W, queued: true, position: queue.length }
-      };
+      queue.push({ handle, call: shown.call, ctx, registered: Promise.resolve() });
+      reportPending();
+      return queuedResult(shown.call, "queued", handle, queue.length);
     }
   });
   pi.registerTool({
     name: DELEGATE_CANCEL_TOOL,
     label: "mu delegate cancel",
-    description: `Stop a delegate started by ${DELEGATE_TOOL}: abort its turn and close its pane (keep: true leaves the pane open). No follow-up message is sent for it afterwards.`,
+    description: `Stop a delegate started by ${DELEGATE_TOOL}: abort its turn and close its pane (keep: true leaves the pane open; a mux-free one's child pi is stopped). A queued or refused call is cancelled too (name it by its handle or call_id). The verdict target, if any, gets "no verdict (cancelled)". Its answer is not shown afterwards.`,
     parameters: {
       type: "object",
       properties: {
-        name: { type: "string", description: "Delegate name, e.g. delegate-1" },
+        name: {
+          type: "string",
+          description: "Delegate name (delegate-1), queue handle (queued-2) or call_id"
+        },
         keep: { type: "boolean", description: "Leave the pane open after aborting" }
       },
       required: ["name"],
       additionalProperties: false
     },
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-      track(ctx);
+    async execute(_id, params) {
       const name = typeof params.name === "string" ? params.name : "";
       if (!name) throw new Error("mu_delegate_cancel needs a name");
-      const qi = queue.findIndex((q) => q.handle === name);
+      const cancelCall = async (call2, author, text2) => {
+        try {
+          const f = await calls.finish(call2.callId, {
+            outcome: "cancelled",
+            ...text2 ? { text: text2 } : {},
+            author
+          });
+          if (f.recorded && call2.record)
+            return ` Recorded on ${call2.record.workstream}/${call2.record.task} as a note (no verdict: cancelled).`;
+          return f.changed ? ` Task ${call2.workstream}/${call2.task} closed (cancelled).` : "";
+        } catch (e) {
+          return ` Recording the cancel failed: ${errText(e)}.`;
+        }
+      };
+      const qi = queue.findIndex((q) => q.handle === name || q.call.callId === name);
       if (qi >= 0) {
         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))}` : "";
+        reportPending();
+        let recorded = "";
+        if (q) {
+          await q.registered.catch(() => {
+          });
+          recorded = await cancelCall(q.call, q.handle);
+        }
         return {
           content: [
             { type: "text", text: `Dropped ${name} from the queue; it never started.${recorded}` }
           ],
-          details: { name, workstream: W }
+          details: { name, workstream: q?.call.workstream ?? W }
+        };
+      }
+      const found = [...inflight].find(
+        ([key2, e]) => key2 === name || key2 === inflightKey(e.call.workstream, name) || e.call.callId === name
+      );
+      if (!found && callIdIn(name)) {
+        const shown = await calls.show(name).catch((e) => {
+          throw new Error(`mu_delegate_cancel: ${errText(e)}`);
+        });
+        const recorded = await cancelCall(shown.call, name);
+        return {
+          content: [{ type: "text", text: `Cancelled ${name} (${shown.state}).${recorded}` }],
+          details: { name, workstream: shown.call.workstream }
+        };
+      }
+      const key = found?.[0];
+      const entry2 = found?.[1];
+      const ws = entry2?.call.workstream ?? W;
+      const agentName = key ? key.slice(key.indexOf("/") + 1) : name;
+      if (entry2?.process && key) {
+        entry2.abort.abort();
+        forget(key);
+        await entry2.process;
+        await finishOrphan(entry2.call, "cancelled", "cancelled");
+        const shown = await calls.show(entry2.call.callId).catch(() => void 0);
+        const where = entry2.call.record ? ` Recorded on ${entry2.call.record.workstream}/${entry2.call.record.task} as a note (no verdict: cancelled).` : "";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Cancelled ${ws}/${agentName} (child pi stopped; call ${shown?.state ?? "cancelling"}).${where}`
+            }
+          ],
+          details: { name: agentName, workstream: ws }
         };
       }
-      const entry = inflight.get(name);
-      if (entry) entry.cancelling = true;
-      const ab = await mu(["agent", "abort", name, "-w", W]);
+      if (entry2) entry2.cancelling = true;
+      const ab = await mu(["agent", "abort", agentName, "-w", ws]);
       if (ab.code !== 0) {
-        if (entry) {
-          entry.cancelling = false;
-          const parked = entry.parked;
-          entry.parked = void 0;
+        if (entry2) {
+          entry2.cancelling = false;
+          const parked = entry2.parked;
+          entry2.parked = void 0;
           if (parked) void parked();
         }
-        throw failure(`mu agent abort ${W}/${name}`, ab);
+        throw failure(`mu agent abort ${ws}/${agentName}`, ab);
       }
-      if (entry) {
-        entry.abort.abort();
-        forget(name);
+      if (entry2 && key) {
+        entry2.abort.abort();
+        forget(key);
       }
-      failed.delete(name);
-      let text = `Aborted ${W}/${name}.`;
-      const sessionFile = entry?.sessionFile;
-      const partial = sessionFile ? partialCopy(name, sessionFile) : void 0;
-      const evidence = evidenceLines({
-        ...sessionFile ? { sessionFile } : {},
-        ...partial ? { partial } : {}
-      });
-      if (entry?.record)
-        text += ` ${await writeRecord(entry.record.target, name, recordNote(entry.record.label, name, "cancelled", void 0, 0))}`;
+      let text = `Aborted ${ws}/${agentName}.`;
+      const sessionFile = entry2?.sessionFile;
+      const evidence = evidenceLines({ ...sessionFile ? { sessionFile } : {} });
+      if (entry2)
+        text += await cancelCall(
+          entry2.call,
+          agentName,
+          sessionFile ? lastAssistantTextIn(sessionFile) : void 0
+        );
       if (params.keep === true) text += " Pane kept.";
       else {
-        const c = await mu(["agent", "close", name, "-w", W]);
-        text += c.code === 0 ? " Pane closed." : ` Pane kept: close refused: ${(c.stderr || c.stdout).trim()}`;
+        const c = await closeDelegate(agentName, entry2?.identity, ws);
+        text += c.closed ? " Pane closed." : ` Pane kept: ${c.why}`;
       }
       if (evidence.length > 0) text += `
 ${evidence.join("\n")}`;
-      return { content: [{ type: "text", text }], details: { name, workstream: W } };
+      return { content: [{ type: "text", text }], details: { name: agentName, workstream: ws } };
     }
   });
   pi.on("message_start", (e) => {
     const m = e.message;
     if (m?.role !== "custom" || m.customType !== DELEGATE_MESSAGE_TYPE) return;
-    const id = m.details?.delivery;
-    if (typeof id === "number" && arriving.delete(id)) showStatus();
+    const id = m.details?.wake;
+    if (typeof id !== "number") return;
+    for (const c of arriving.get(id)?.calls ?? []) owed.delete(c);
+    arriving.delete(id);
   });
-  pi.on("agent_settled", (e) => {
-    if (e.aborted !== true) return;
-    const dropped = [];
-    for (const [id, a] of arriving) {
-      if (!a.queued) continue;
+  const dropWakes = (ids, also = []) => {
+    const names = new Set(also);
+    for (const id of ids) {
+      const a = arriving.get(id);
+      if (!a) continue;
       arriving.delete(id);
-      dropped.push({
-        name: a.name,
-        ...a.outcome ? { outcome: a.outcome } : {},
-        ...a.elapsedMs !== void 0 ? { elapsedMs: a.elapsedMs } : {},
-        ...a.sessionFile ? { sessionFile: a.sessionFile } : {},
-        ...a.content ? { copy: saveCopy(a.name, a.content) } : {}
-      });
+      for (const o of a.opts ?? []) o.triggerTurn = false;
+      for (const c of a.calls) names.add(c);
     }
+    const dropped = [];
+    for (const c of names) {
+      const a = owed.get(c);
+      if (!a) continue;
+      owed.delete(c);
+      dropped.push(a);
+    }
+    trace("dropped", { calls: dropped.map((d) => d.callId) });
     if (dropped.length === 0) return;
-    showStatus();
     void Promise.resolve(
-      pi.sendMessage(
+      send(
         {
           customType: DELEGATE_MESSAGE_TYPE,
           content: droppedNote(dropped),
           display: true,
-          details: { dropped }
+          details: { dropped: dropped.map((d) => d.callId) }
         },
-        { triggerTurn: false }
+        { triggerTurn: false },
+        "dropped-note"
       )
     ).catch(() => {
     });
+  };
+  const recoverLost = (candidates, ctx) => {
+    settleCheck = void 0;
+    if (closed) return;
+    let idle = false;
+    try {
+      idle = ctx.isIdle?.() ?? true;
+    } catch {
+    }
+    if (!idle) return;
+    if ([...arriving].some(([id, a2]) => a2.sent && !candidates.includes(id))) return;
+    const lost = candidates.filter((id) => arriving.get(id)?.sent);
+    dropWakes(lost.filter((id) => arriving.get(id)?.resent));
+    const next = lost.find((id) => arriving.has(id));
+    const a = next === void 0 ? void 0 : arriving.get(next);
+    if (next === void 0 || !a?.message) {
+      wake("wake-after-settle");
+      return;
+    }
+    a.resent = true;
+    trace("resend", { wake: next, calls: a.calls });
+    void Promise.resolve(
+      send(a.message, { deliverAs: "followUp", triggerTurn: true }, "resend")
+    ).catch(() => {
+      arriving.delete(next);
+    });
+  };
+  pi.on("agent_start", () => {
+    busy = true;
   });
-  pi.on("session_shutdown", (_e, ctx) => {
-    if (arriving.size > 0) {
-      arriving.clear();
-      showStatus();
+  pi.on("agent_settled", (e, ctx) => {
+    busy = false;
+    const sent = [...arriving].filter(([, a]) => a.sent).map(([id]) => id);
+    if (e.aborted === true) {
+      clearImmediate(settleCheck);
+      dropWakes(sent, [...owed.keys()]);
+      return;
+    }
+    if (sent.length === 0 && owed.size === 0) return;
+    clearImmediate(settleCheck);
+    settleCheck = setImmediate(() => recoverLost(sent, ctx));
+  });
+  pi.on("session_start", async (_e, ctx) => {
+    const session = piSessionId(ctx) || process.env.PI_SESSION_ID;
+    if (!session || closed) return;
+    const r = await mu(["delegates", "list", "--caller", `pi:${session}`, "--json"]).catch(
+      () => void 0
+    );
+    const items = (r ? json(r)?.items : void 0) ?? [];
+    for (const row of items) {
+      if (row.state !== "running" || typeof row.agent !== "string" || row.agent === row.task)
+        continue;
+      const call2 = callInfoOf(row);
+      if (call2.caller !== `pi:${session}` || inflight.has(inflightKey(call2.workstream, row.agent)))
+        continue;
+      const since = typeof row.updatedAt === "string" ? Date.parse(row.updatedAt) : Number.NaN;
+      await watch(call2, row.agent, 0, {
+        keep: call2.request.keep === true,
+        timeoutS: call2.request.timeoutS ?? DELEGATE_TIMEOUT_S,
+        ...Number.isFinite(since) ? { startedAt: since } : {}
+      });
     }
+  });
+  pi.on("session_shutdown", async (e, ctx) => {
+    closed = true;
+    clearImmediate(settleCheck);
+    clearImmediate(wakeSoon);
+    trace("session_shutdown.state", {
+      arriving: [...arriving.values()].map((a) => ({ calls: a.calls, sent: a.sent })),
+      owed: [...owed.keys()],
+      inflight: [...inflight.keys()]
+    });
+    arriving.clear();
+    owed.clear();
     if (inflight.size === 0 && queue.length === 0) return;
-    const names = [...inflight.keys()];
+    const shown = (key) => key.startsWith(`${W}/`) ? key.slice(W.length + 1) : key;
+    const names = [...inflight].flatMap(([k, e2]) => e2.process ? [] : [shown(k)]);
+    const procs = [...inflight].flatMap(([k, e2]) => e2.process ? [shown(k)] : []);
     const sessions = [...inflight].flatMap(
-      ([n, e]) => e.sessionFile ? [`${n}: ${e.sessionFile}`] : []
+      ([k, e2]) => e2.sessionFile ? [`${shown(k)}: ${e2.sessionFile}`] : []
     );
-    const never = queue.splice(0).map((q) => q.handle);
-    for (const e of inflight.values()) e.abort.abort();
+    const dropped = queue.splice(0);
+    const reason2 = e?.reason;
+    const replacing = reason2 === "reload" || reason2 === "new" || reason2 === "resume" || reason2 === "fork";
+    const stopping = [];
+    for (const f of inflight.values())
+      if (!f.process || !replacing) {
+        f.abort.abort();
+        const call2 = f.call;
+        if (f.process)
+          stopping.push(f.process.then(() => finishOrphan(call2, "cancelled", "pi quit")));
+      }
     inflight.clear();
-    showStatus();
-    ui = void 0;
+    reportPending();
+    await Promise.all(stopping);
+    const refused = [];
+    await Promise.all(
+      dropped.map(async (q) => {
+        try {
+          await q.registered;
+          await calls.mark(q.call.callId, "refused", {
+            error: "its session ended before it started"
+          });
+          refused.push(q.call.callId);
+        } catch {
+        }
+      })
+    );
     const parts = [];
     if (names.length > 0)
       parts.push(
-        `${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.`
+        `${names.length} delegate${names.length === 1 ? "" : "s"} still running: ${names.join(", ")}. ${reason2 === "reload" ? "This session's next runtime re-adopts them and delivers their answers." : `Their answers will not come back here; use mu agent wait <name> -w ${W} --json.`}`
+      );
+    if (procs.length > 0)
+      parts.push(
+        replacing ? `${procs.length} mux-free delegate${procs.length === 1 ? "" : "s"} still running: ${procs.join(", ")}. Each finishes onto its task (mu task notes <name> -w ${W}); the answer will not come back here.` : `${procs.length} mux-free delegate${procs.length === 1 ? "" : "s"} cancelled: ${procs.join(", ")}.`
       );
     if (sessions.length > 0) parts.push(`Sessions: ${sessions.join("; ")}.`);
-    if (never.length > 0)
-      parts.push(`${never.length} queued, never started: ${never.join(", ")}. Re-issue them.`);
+    if (dropped.length > 0)
+      parts.push(
+        `${dropped.length} queued, never started: ${dropped.map((q) => q.handle).join(", ")}. Re-issue them${refused.length > 0 ? ` (durable and refused: ${DELEGATE_REISSUE_TOOL} in a new pi session; list: mu delegates --all)` : ""}.`
+      );
     const msg = parts.join(" ");
     if (ctx?.hasUI && ctx.ui) ctx.ui.notify(msg, "warning");
     else process.stderr.write(`mu: ${msg}
 `);
   });
-  return { answerPending: () => arriving.size > 0 };
+  return {
+    answerPending: () => arriving.size > 0,
+    delivered(shown) {
+      if (Array.isArray(shown)) for (const c of shown) owed.delete(c);
+      else
+        for (const [c, a] of owed) if (a.at < shown.before) owed.delete(c);
+    }
+  };
 }
 
 // extension/nudge.ts
@@ -903,14 +1631,12 @@ import { join as join3 } 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;
 var noHold = () => void 0;
 function withQueuedInput(hold) {
-  return (ctx) => ctx?.hasPendingMessages?.() ? "answer" : hold(ctx);
+  return (ctx) => ctx?.hasPendingMessages?.() ? "input" : hold(ctx);
 }
 function noUI(ctx) {
   return ctx?.hasUI === false;
@@ -922,7 +1648,7 @@ 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();
+  const text = skillMd.slice(i + MARK_START.length, j).trim().split(/\n\s*\n/).map((p) => p.replace(/\s*\n\s*/g, " ")).join("\n\n");
   return text === "" ? void 0 : text;
 }
 function readSkill() {
@@ -932,190 +1658,13 @@ function readSkill() {
   }
   return void 0;
 }
-var ENV_ASSIGN = /^[A-Za-z_][A-Za-z0-9_]*=/;
-function muArgs(words) {
-  let at = 0;
-  while (at < words.length && ENV_ASSIGN.test(words[at] ?? "")) at++;
-  const cmd = words[at];
-  if (cmd !== "mu" && !cmd?.endsWith("/mu")) return void 0;
-  return words.slice(at + 1);
-}
-function dispatchedWorkstreams(command) {
-  const found = /* @__PURE__ */ new Set();
-  for (const words of shellSegments(command)) {
-    const args = muArgs(words);
-    if (args === void 0) continue;
-    const claim = claimOf(args);
-    if (claim !== void 0) {
-      if (claim.ws !== "scratch") found.add(claim.ws);
-      continue;
-    }
-    if (args[0] !== "agent" || args[1] !== "send" && args[1] !== "spawn") continue;
-    let ws = "";
-    for (let k = 2; k < args.length; k++) {
-      const w = args[k] ?? "";
-      if (w === "-w" || w === "--workstream") ws = args[k + 1] ?? "";
-      else if (w.startsWith("--workstream=")) ws = w.slice("--workstream=".length);
-    }
-    if (ws !== "scratch") found.add(ws);
-  }
-  return found.size > 0 ? [...found] : void 0;
-}
-var CLAIM_VALUE_OPTS = /* @__PURE__ */ new Set(["--for", "-f", "-w", "--workstream", "--evidence", "--actor"]);
-function shellSegments(command) {
-  const segs = [];
-  let words = [];
-  let word;
-  const heredocs = [];
-  let arithEnd = -1;
-  const endWord = () => {
-    if (word !== void 0) words.push(word);
-    word = void 0;
-  };
-  const endSeg = () => {
-    endWord();
-    if (words.length > 0) segs.push(words);
-    words = [];
-  };
-  const skipHeredocs = (i) => {
-    for (const h of heredocs.splice(0)) {
-      while (i < command.length) {
-        const eol = command.indexOf("\n", i + 1);
-        const end = eol < 0 ? command.length : eol;
-        const line = command.slice(i + 1, end);
-        i = end;
-        if ((h.strip ? line.replace(/^\t+/, "") : line) === h.delim) break;
-      }
-    }
-    return i;
-  };
-  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 === "\\" && command[i + 1] === "\n") {
-      i++;
-    } else if (c === "\\" && i + 1 < command.length) {
-      word = (word ?? "") + command[++i];
-    } else if (c === "#" && word === void 0) {
-      const eol = command.indexOf("\n", i);
-      i = (eol < 0 ? command.length : eol) - 1;
-    } else if (c === "(" && command[i + 1] === "(" && i > arithEnd) {
-      arithEnd = arithmeticEnd(command, i);
-      word = `${word ?? ""}((`;
-      i++;
-    } else if (command.startsWith("<<<", i)) {
-      endWord();
-      i += 2;
-    } else if (c === "<" && command[i + 1] === "<" && i > arithEnd) {
-      endWord();
-      const m = /^<<(-?)[ \t]*('([^']*)'|"([^"]*)"|[^\s;&|<>()]+)/.exec(command.slice(i));
-      if (!m) {
-        i++;
-        continue;
-      }
-      const delim = m[3] ?? m[4] ?? (m[2] ?? "").replace(/\\/g, "");
-      heredocs.push({ delim, strip: m[1] === "-" });
-      i += m[0].length - 1;
-    } else if (c === ";" || c === "|" || c === "\n" || c === "&" && command[i + 1] === "&") {
-      if (c !== ";" && c !== "\n" && command[i + 1] === c) i++;
-      endSeg();
-      if (c === "\n" && heredocs.length > 0) i = skipHeredocs(i);
-    } else if (/\s/.test(c)) {
-      endWord();
-    } else {
-      word = (word ?? "") + c;
-    }
-  }
-  endSeg();
-  return segs;
-}
-function arithmeticEnd(command, open) {
-  let depth = 0;
-  for (let i = open + 2; i < command.length; i++) {
-    const c = command[i];
-    if (c === "'" || c === '"') {
-      const close = command.indexOf(c, i + 1);
-      if (close < 0) return -1;
-      i = close;
-    } else if (c === "\\") {
-      i++;
-    } else if (c === "(") {
-      depth++;
-    } else if (c === ")") {
-      if (depth > 0) depth--;
-      else return command[i + 1] === ")" ? i + 1 : -1;
-    }
-  }
-  return -1;
-}
-function claimOf(args) {
-  if (args[0] !== "task" || args[1] !== "claim") return void 0;
-  let ws = "";
-  let id;
-  let isFor = false;
-  for (let k = 2; k < args.length; k++) {
-    const w = args[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 ?? args[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) return void 0;
-  const slash = id.indexOf("/");
-  if (slash >= 0) {
-    if (ws === "") ws = id.slice(0, slash);
-    id = id.slice(slash + 1);
-  }
-  return { ws, id };
-}
-function dispatchedTasks(command) {
-  const out = [];
-  for (const words of shellSegments(command)) {
-    const args = muArgs(words);
-    const claim = args === void 0 ? void 0 : claimOf(args);
-    if (claim !== void 0 && claim.ws !== "scratch") out.push(claim);
-  }
-  return out;
-}
-async function inProgress(run, workstreams) {
-  const results = await Promise.all(
-    workstreams.map(async (w) => {
-      const r = await run([
-        "task",
-        "list",
-        "--status",
-        "IN_PROGRESS",
-        "--json",
-        "--sort",
-        "recency",
-        ...w ? ["-w", w] : []
-      ]);
-      if (r.code !== 0) return void 0;
-      try {
-        const items = JSON.parse(r.stdout).items ?? [];
-        return items.flatMap((t) => t.name ? [`${t.workstreamName ?? w}/${t.name}`] : []);
-      } catch {
-        return void 0;
-      }
-    })
-  );
-  if (results.some((r) => r === void 0)) return void 0;
-  return [...new Set(results.flatMap((r) => r ?? []))];
-}
-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");
+async function allItems(run, argv, uncapped) {
+  const r = await run([...argv, uncapped]);
+  if (r.code !== 0) return void 0;
+  const data = parseEnvelope(r.stdout);
+  if (data === void 0 || !Array.isArray(data.items)) return void 0;
+  if ((data.more ?? 0) > 0) return void 0;
+  return data.items;
 }
 function breadcrumb(run, args) {
   void run(args).catch(() => {
@@ -1149,7 +1698,8 @@ function parallelSettle(pi, hold = noHold) {
         const late = hold(ctx);
         const fired = results.flatMap((r) => {
           if (r === void 0) return [];
-          if (late === "answer" || late === "blocked" && r.continue === true) {
+          if (r.receipt === true && late !== void 0) return [{ entries: r.entries ?? [] }];
+          if (late === "input" || late === "wake" || late === "blocked" && r.continue === true) {
             r.yielded?.();
             return [];
           }
@@ -1176,54 +1726,305 @@ function parallelSettle(pi, hold = noHold) {
 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;
+var SETTLE_DRAIN_MS = 3e3;
+var SETTLE_WAIT_ARGS = ["wait", "--first", "--on-stall", "exit", "--json"];
+var SETTLE_READY_ARGS = [
+  "wait",
+  "--first",
+  "--on-stall",
+  "exit",
+  "--timeout",
+  "1",
+  "--json"
+];
+var READY_MAX = 50;
+var ESC = /^\u001b(\[27(;\d+)*u)?$/;
+function envelopeOf(stdout) {
+  try {
+    const v = JSON.parse(stdout);
+    return typeof v === "object" && v !== null && typeof v.ok === "boolean" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sessionIdOf(ctx) {
+  try {
+    return ctx?.sessionManager?.getSessionId?.() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function identityEnvs(sid) {
+  const e = process.env;
+  const out = [];
+  if (e.MU_MANAGED_AGENT === "1" && e.MU_WORKSTREAM && e.MU_AGENT_NAME)
+    out.push({ PI_SESSION_ID: void 0 });
+  if (sid !== void 0) out.push({ MU_MANAGED_AGENT: void 0, PI_SESSION_ID: sid });
+  return out;
+}
+async function humanNeeds(run, sid) {
+  const counts = await Promise.all(
+    identityEnvs(sid).map(async (env) => {
+      const r = await run(["state", "--me", "--all", "--full", "--json"], void 0, void 0, {
+        env
+      }).catch(() => void 0);
+      const env0 = r === void 0 ? void 0 : envelopeOf(r.stdout);
+      const ws = env0?.ok === true ? env0.data?.workstreams : void 0;
+      if (!Array.isArray(ws)) return void 0;
+      return ws.reduce(
+        (n, w) => n + (w.human_needs?.length ?? 0),
+        0
+      );
+    })
+  );
+  return counts.some((c) => c === void 0) ? void 0 : counts.reduce((a, b) => a + (b ?? 0), 0);
+}
+function entry(content) {
+  return { type: "custom_message", customType: NUDGE_MESSAGE_TYPE, content, display: true };
+}
+var REPORT_CAP = 4e3;
+var WAVE_REPORT_CAP = 1500;
+var PENDING_STATES = /* @__PURE__ */ new Set(["queued", "starting", "running", "recording"]);
+var recordOf = (c) => c.record?.workstream && c.record.task ? `${c.record.workstream}/${c.record.task}` : void 0;
+async function reportOf(mu, c) {
+  const v = await mu(["task", "notes", c.task, "-w", c.workstream, "--json"]);
+  const items = v?.ok === true ? v.data?.items : void 0;
+  return items?.filter((n) => n.kind === "report").at(-1)?.content;
+}
+async function answerBlock(mu, c, cap) {
+  const where = recordOf(c);
+  const notes = `mu task notes ${c.task} -w ${c.workstream}`;
+  const head = [
+    `Delegate answer: call ${c.callId}, task ${c.workstream}/${c.task}, ${c.state}`,
+    c.verdict ? `, ${c.verdict}` : "",
+    where ? `, recorded on ${where}` : "",
+    c.error ? `. Error: ${c.error}` : "",
+    "."
+  ].join("");
+  if (where && c.verdict) return `${head} Full answer: ${notes}`;
+  const text = await reportOf(mu, c);
+  if (text === void 0) return `${head} Report unreadable here; read it: ${notes}`;
+  const body = text.length > cap ? `${text.slice(0, cap)}
+[... ${text.length - cap} more characters: ${notes}]` : text;
+  return `${head}
+${body}`;
+}
+function waveSummary(wave, rows) {
+  const n = (p) => rows.filter(p).length;
+  const refused = rows.filter((c) => c.state === "refused");
+  const counts = [
+    `${n((c) => c.verdict === "CONFIRMED")}/${rows.length} CONFIRMED`,
+    `${n((c) => c.verdict === "REFUTED")} REFUTED`,
+    `${n((c) => c.state !== "refused" && !PENDING_STATES.has(c.state) && c.verdict !== "CONFIRMED" && c.verdict !== "REFUTED")} UNVERIFIED`,
+    `${n((c) => PENDING_STATES.has(c.state))} pending`,
+    `${refused.length} refused`
+  ].join(", ");
+  const lines = rows.map(
+    (c) => `- ${recordOf(c) ?? `${c.workstream}/${c.task}`}: ${c.state === "refused" ? "REFUSED, reissue it: mu_delegate_reissue" : c.verdict ?? c.state} (call ${c.callId})`
+  );
+  return [`Wave ${wave}: ${counts}.`, ...lines].join("\n");
+}
+function noticesOf(d) {
+  return Array.isArray(d.notices) ? d.notices.filter((n) => typeof n === "string") : [];
+}
+function firingDelegate(d) {
+  const f = d.firing;
+  if (f?.kind !== "delegate" || typeof f.ref !== "string") return void 0;
+  return f.ref.startsWith("delegate:") ? f.ref.slice("delegate:".length) : void 0;
+}
+function pictureOf(d) {
+  if (typeof d.snapshotsCut === "number" && d.snapshotsCut > 0) return void 0;
+  const snaps = Array.isArray(d.snapshots) ? d.snapshots : [];
+  return new Set(
+    snaps.flatMap(
+      (s) => typeof s.ref === "string" && s.ref.startsWith("delegate:") ? [s.ref.slice("delegate:".length)] : []
+    )
+  );
 }
-function registerNudge(pi, run = defaultRunner(), skillMd = readSkill(), nested = notNested, hold = noHold) {
+var noDelivered = () => {
+};
+function registerNudge(pi, run = defaultRunner(), skillMd = readSkill(), nested = notNested, hold = noHold, delivered = noDelivered) {
   if (!nudgeEnabled()) return;
+  if (process.env.MU_REMOTE === "1") 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);
-  });
+  let current;
+  const cancel = () => current?.abort();
+  pi.on("input", cancel);
+  pi.on("ui_prompt_start", cancel);
+  pi.on("session_shutdown", cancel);
   pi.on("agent_before_settle", async (event, ctx) => {
-    if (fired || armed.size === 0 || nested() || hold(ctx)) return;
+    if (nested() || hold(ctx)) return;
     if (outcomeOf(event) !== "completed") return;
-    fired = true;
-    const refs = await inProgress(run, [...armed]);
-    if (refs === void 0 || refs.length === 0) return;
-    if (hold(ctx)) {
-      fired = false;
-      return;
-    }
-    const text = nudgeText(rule, refs);
-    const logWs = [...armed].find((w) => w !== "");
-    breadcrumb(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,
-      yielded: () => {
-        fired = false;
+    const sid = sessionIdOf(ctx);
+    if (identityEnvs(sid).length === 0) return;
+    const env = { PI_SESSION_ID: sid };
+    const ctl = new AbortController();
+    current = ctl;
+    const off = ctx?.ui?.onTerminalInput?.((data) => {
+      if (ESC.test(data)) ctl.abort();
+      return void 0;
+    }) ?? (() => {
+    });
+    const wait = (args) => run(args, ctl.signal, void 0, { env, drainMs: SETTLE_DRAIN_MS });
+    const mu = async (args) => envelopeOf(
+      (await run(args, void 0, void 0, { env }).catch(() => void 0))?.stdout ?? ""
+    );
+    const call2 = async (id) => {
+      const v = await mu(["delegates", "show", id, "--json"]);
+      return v?.ok === true ? v.data?.call : void 0;
+    };
+    const answers = async (callId, shown, first) => {
+      shown.add(callId);
+      const c = await call2(callId);
+      if (c === void 0)
+        return {
+          blocks: [
+            `Delegate answer: call ${callId}. Its row is unreadable here: mu delegates show ${callId}`
+          ],
+          stop: false
+        };
+      const wave = c.wave;
+      if (!wave) return { blocks: [await answerBlock(mu, c, REPORT_CAP)], stop: false };
+      const listed = async () => {
+        const v = await mu(["delegates", "list", "--wave", wave, "--json"]);
+        const items = v?.ok === true ? v.data?.items : void 0;
+        return Array.isArray(items) ? items : [c];
+      };
+      const after = [];
+      const notices = new Set(noticesOf(first));
+      let stop = false;
+      let rows = await listed();
+      let picture = pictureOf(first);
+      const owedRow = (r) => PENDING_STATES.has(r.state) || r.state !== "refused" && !shown.has(r.callId) && picture?.has(r.callId) !== false;
+      while (!ctl.signal.aborted && rows.some(owedRow)) {
+        const r = await wait(SETTLE_WAIT_ARGS);
+        const v = envelopeOf(r.stdout);
+        if (v?.ok === false && v.error === "WaitNothingError") break;
+        const d = v?.ok === true ? v.data : void 0;
+        if (d === void 0) {
+          after.push(
+            `The wave's wait failed (exit ${r.code}): ${(r.stdout.trim() || r.stderr.trim()).slice(0, 500)}`
+          );
+          break;
+        }
+        if (d.interrupted === true || d.drained === true) break;
+        for (const n of noticesOf(d)) notices.add(n);
+        picture = pictureOf(d);
+        if (d.timedOut === true) continue;
+        if (Array.isArray(d.humanNeeds) && d.humanNeeds.length > 0) stop = true;
+        const id = firingDelegate(d);
+        const sibling = id !== void 0 && rows.some((x) => x.callId === id);
+        if (id !== void 0) shown.add(id);
+        if (sibling && !stop) {
+          rows = await listed();
+          continue;
+        }
+        after.push(`Another event came before the rest of wave ${wave}:
+${JSON.stringify(d)}`);
+        const oc = id === void 0 || sibling ? void 0 : await call2(id);
+        if (oc) after.push(await answerBlock(mu, oc, REPORT_CAP));
+        break;
+      }
+      rows = await listed();
+      const complete = !ctl.signal.aborted && after.length === 0 && !rows.some(owedRow);
+      const bodies = await Promise.all(
+        rows.filter((x) => shown.has(x.callId)).map((x) => answerBlock(mu, x, WAVE_REPORT_CAP))
+      );
+      return {
+        blocks: [waveSummary(wave, rows), ...bodies, ...after],
+        stop,
+        wave: { label: wave, complete, notices: [...notices] }
+      };
+    };
+    const ready = async () => {
+      const blocks = [];
+      const shown = [];
+      for (let i = 0; i < READY_MAX && !ctl.signal.aborted; i++) {
+        const started = Date.now();
+        const r = await wait(SETTLE_READY_ARGS);
+        const v = envelopeOf(r.stdout);
+        if (v?.ok === false && v.error === "WaitNothingError") {
+          delivered({ before: started });
+          break;
+        }
+        const d = v?.ok === true ? v.data : void 0;
+        if (d === void 0) {
+          const why = (r.stdout.trim() || r.stderr.trim()).slice(0, 2e3);
+          blocks.push(`mu wait failed (exit ${r.code}): ${why}`);
+          break;
+        }
+        if (d.drained === true) delivered({ before: started });
+        if (d.interrupted === true || d.drained === true || d.timedOut === true) break;
+        blocks.push(JSON.stringify(d));
+        const id = firingDelegate(d);
+        if (id === void 0) continue;
+        shown.push(id);
+        const c = await call2(id);
+        blocks.push(
+          c === void 0 ? `Delegate answer: call ${id}. Its row is unreadable here: mu delegates show ${id}` : await answerBlock(mu, c, REPORT_CAP)
+        );
       }
+      if (shown.length > 0) delivered(shown);
+      if (blocks.length === 0) return void 0;
+      const text = [
+        "[mu] A human stop is open (mu human-needed), so the settle did not wait. It showed what was already ready:",
+        ...blocks.flatMap((b) => ["", b])
+      ].join("\n");
+      return { entries: [entry(text)], receipt: true };
     };
+    let result;
+    try {
+      result = await (async () => {
+        for (; ; ) {
+          const needs = await humanNeeds(run, sid);
+          if (ctl.signal.aborted || hold(ctx)) return void 0;
+          if (needs === void 0)
+            return {
+              entries: [
+                entry(
+                  "[mu] settle: could not read your open human needs (mu state --me); not waiting."
+                )
+              ]
+            };
+          if (needs > 0) return ready();
+          const started = Date.now();
+          const r = await wait(SETTLE_WAIT_ARGS);
+          const v = envelopeOf(r.stdout);
+          if (v?.ok === false && v.error === "WaitNothingError") {
+            delivered({ before: started });
+            return void 0;
+          }
+          if (v === void 0 || v.ok !== true || v.data === void 0) {
+            const why = (r.stdout.trim() || r.stderr.trim()).slice(0, 2e3);
+            return { entries: [entry(`[mu] settle: mu wait failed (exit ${r.code}): ${why}`)] };
+          }
+          const d = v.data;
+          if (d.drained === true) delivered({ before: started });
+          if (d.interrupted === true || d.drained === true) return void 0;
+          if (d.timedOut === true) continue;
+          const callId = firingDelegate(d);
+          const shown = /* @__PURE__ */ new Set();
+          const got = callId === void 0 ? void 0 : await answers(callId, shown, d);
+          const blocks = got?.blocks ?? [];
+          if (shown.size > 0) delivered([...shown]);
+          const humanStop = Array.isArray(d.humanNeeds) && d.humanNeeds.length > 0;
+          const stop = humanStop || got?.stop === true;
+          const ran = `Work you own is still running, so the settle ran \`mu ${SETTLE_WAIT_ARGS.join(" ")}\` for you.`;
+          const w = got?.wave;
+          const head = w !== void 0 && !humanStop ? [
+            w.complete ? `${ran} It waited until wave ${w.label} was in:` : `${ran} It waited for wave ${w.label}, which is not all in (below):`,
+            ...w.notices.map((n) => `Notice: ${n}`)
+          ] : [`${ran} Its result:`, JSON.stringify(d)];
+          const text = [`[mu] ${rule}`, "", ...head, ...blocks.flatMap((b) => ["", b])].join("\n");
+          return { entries: [entry(text)], ...stop ? {} : { continue: true }, receipt: true };
+        }
+      })();
+    } finally {
+      off();
+      if (current === ctl) current = void 0;
+    }
+    return result;
   });
 }
 function workerIdentity(env = process.env) {
@@ -1233,12 +2034,15 @@ function workerIdentity(env = process.env) {
   return { agent, workstream };
 }
 async function ownedInProgress(run, agent, workstream) {
-  const r = await run(["task", "owned-by", agent, "-w", workstream, "--json"]);
-  if (r.code !== 0) return void 0;
   try {
-    const json = JSON.parse(r.stdout);
-    return (json.items ?? []).flatMap(
-      (t) => t.status === "IN_PROGRESS" && t.name ? [t.name] : []
+    const items = await allItems(
+      run,
+      ["task", "owned-by", agent, "-w", workstream, "--json"],
+      "--full"
+    );
+    if (items === void 0) return void 0;
+    return items.flatMap(
+      (t) => t.status === "IN_PROGRESS" && t.kind !== "delegate" && t.id ? [t.id] : []
     );
   } catch {
     return void 0;
@@ -1255,6 +2059,7 @@ function closeNudgeText(workstream, names) {
 }
 function registerCloseNudge(pi, run = defaultRunner(), env = process.env, nested = notNested, hold = noHold) {
   if (!nudgeEnabled(env)) return;
+  if (env.MU_REMOTE === "1") return;
   const me = workerIdentity(env);
   if (me === void 0) return;
   let fired = false;
@@ -1295,74 +2100,9 @@ function registerCloseNudge(pi, run = defaultRunner(), env = process.env, nested
     };
   });
 }
-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, hold = noHold) {
-  if (!nudgeEnabled()) return;
-  const answerDue = (ctx) => hold(ctx) === "answer";
-  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) || answerDue(ctx)) return;
-    if (outcomeOf(event) !== "completed") return;
-    fired = true;
-    const tasks = [...armed];
-    const refuted = await Promise.all(tasks.map(([, t]) => briefRefuted(run, t.ws, t.id)));
-    const refs = tasks.flatMap(([ref], i) => refuted[i] === false ? [ref] : []);
-    if (refs.length === 0) return;
-    if (answerDue(ctx)) {
-      fired = false;
-      return;
-    }
-    const logWs = [...armed.values()].find((t) => t.ws !== "")?.ws;
-    breadcrumb(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
-        }
-      ],
-      yielded: () => {
-        fired = false;
-      }
-    };
-  });
-}
 
 // extension/mu-pi.ts
-var EXT_VERSION = true ? "3.13.3" : void 0;
+var EXT_VERSION = true ? "4.1.0" : void 0;
 var FRESH_COMMAND = "mu-fresh";
 var FRESH_TIMEOUT_MS = 3e4;
 function commandName(name) {
@@ -1378,9 +2118,9 @@ function fail(error) {
 }
 function detectPiVersion() {
   try {
-    const entry = process.argv[1];
-    if (!entry) return void 0;
-    let dir = dirname(realpathSync(entry));
+    const entry2 = process.argv[1];
+    if (!entry2) return void 0;
+    let dir = dirname(realpathSync(entry2));
     for (let i = 0; i < 6; i++) {
       const pkgPath = join4(dir, "package.json");
       if (existsSync3(pkgPath)) {
@@ -1416,22 +2156,22 @@ function sharedMap() {
 }
 function lastAssistantText(event) {
   const msgs = typeof event === "object" && event !== null ? event.messages : void 0;
-  if (!Array.isArray(msgs)) return "";
+  if (!Array.isArray(msgs)) return { text: "", truncated: false };
   for (let i = msgs.length - 1; i >= 0; i--) {
     const m = msgs[i];
     if (typeof m !== "object" || m === null) continue;
     const { role, content } = m;
     if (role !== "assistant") continue;
-    if (typeof content === "string") return capText(content);
-    if (!Array.isArray(content)) return "";
+    if (typeof content === "string") return capTail(content);
+    if (!Array.isArray(content)) return { text: "", truncated: false };
     const parts = content.flatMap((c) => {
       if (typeof c !== "object" || c === null) return [];
       const { type, text } = c;
       return type === "text" && typeof text === "string" ? [text] : [];
     });
-    return capText(parts.join(""));
+    return capTail(parts.join(""));
   }
-  return "";
+  return { text: "", truncated: false };
 }
 function lastAssistantError(event) {
   const msgs = typeof event === "object" && event !== null ? event.messages : void 0;
@@ -1446,6 +2186,13 @@ function lastAssistantError(event) {
   }
   return void 0;
 }
+function capTail(text) {
+  if (Buffer.byteLength(text, "utf8") <= LAST_TEXT_MAX_BYTES) return { text, truncated: false };
+  const buf = Buffer.from(text, "utf8");
+  const tail = buf.subarray(buf.length - LAST_TEXT_MAX_BYTES).toString("utf8").replace(/^\uFFFD/, "");
+  return { text: `${LAST_TEXT_TRUNCATED}
+${tail}`, truncated: true };
+}
 function capText(text) {
   if (Buffer.byteLength(text, "utf8") <= LAST_TEXT_MAX_BYTES) return text;
   const cut = Buffer.from(text, "utf8").subarray(0, LAST_TEXT_MAX_BYTES).toString("utf8");
@@ -1524,38 +2271,15 @@ 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 = join4(here, up, "prompts");
-    if (existsSync3(join4(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) => join4(d, f));
-    return { promptPaths: paths };
-  });
-}
 function muPi(pi, run = defaultRunner()) {
   const delegates = registerDelegate(pi, run);
-  registerPrompts(pi);
   const nested = serveCtl(pi);
   const hold = withQueuedInput(
-    () => delegates.answerPending() ? "answer" : isUiBlocked() ? "blocked" : void 0
+    () => delegates.answerPending() ? "wake" : isUiBlocked() ? "blocked" : void 0
   );
   const settle = parallelSettle(pi, hold);
-  registerNudge(settle.api, run, void 0, nested, hold);
+  registerNudge(settle.api, run, void 0, nested, hold, delegates.delivered);
   registerCloseNudge(settle.api, run, process.env, nested, hold);
-  registerRefuteNudge(settle.api, run, nested, hold);
   settle.flush();
 }
 function serveCtl(pi) {
@@ -1570,25 +2294,42 @@ function serveCtl(pi) {
   const existing = map.get(sockPath);
   const g = existing ?? {
     conns: /* @__PURE__ */ new Set(),
+    incarnation: randomUUID(),
+    accepted: /* @__PURE__ */ new Map(),
     waiters: /* @__PURE__ */ new Set(),
     state: "idle",
     since: Date.now(),
     runs: 0,
+    tools: /* @__PURE__ */ new Map(),
     lastText: "",
     pi,
     handle
   };
   g.pi = pi;
   g.handle = handle;
+  g.incarnation ??= randomUUID();
+  g.accepted ??= /* @__PURE__ */ new Map();
+  g.tools ??= /* @__PURE__ */ new Map();
   map.set(sockPath, g);
   const status = () => ({
+    incarnation: g.incarnation,
     state: g.state,
     since: g.since,
     runs: g.runs,
     pending: g.ctx?.hasPendingMessages() ?? false,
+    tool: [...g.tools.values()].at(-1) ?? null,
     ...sessionFileOf(g.ctx),
     ...blockedField()
   });
+  const remember = (id, runs) => {
+    if (id === void 0) return;
+    g.accepted.delete(id);
+    g.accepted.set(id, { runs, at: Date.now() });
+    for (const old of g.accepted.keys()) {
+      if (g.accepted.size <= CTL_MSGID_MEMORY) break;
+      g.accepted.delete(old);
+    }
+  };
   const blockedField = () => {
     const b = uiBlocked();
     return b ? { blocked: b } : {};
@@ -1614,8 +2355,20 @@ function serveCtl(pi) {
     g.since = Date.now();
     if (g.fresh?.armed) settleFresh({ v: V, ok: true, ...status() });
   });
+  pi.on("tool_execution_start", (e) => {
+    const { toolCallId, toolName } = e ?? {};
+    if (typeof toolCallId === "string" && typeof toolName === "string") {
+      g.tools.set(toolCallId, { name: toolName, since: Date.now() });
+    }
+  });
+  pi.on("tool_execution_end", (e) => {
+    g.tools.delete(String(e?.toolCallId));
+  });
   pi.on("agent_end", (e) => {
-    g.endText = lastAssistantText(e);
+    g.tools.clear();
+    const cut = lastAssistantText(e);
+    g.endText = cut.text;
+    g.endTextTruncated = cut.truncated;
     g.endError = lastAssistantError(e);
   });
   function sessionFileOf(c) {
@@ -1630,9 +2383,12 @@ function serveCtl(pi) {
     g.ctx = c;
     g.state = "idle";
     g.since = Date.now();
+    g.tools.clear();
     g.runs++;
     g.lastText = g.endText ?? "";
+    g.lastTextTruncated = g.endTextTruncated === true;
     g.endText = void 0;
+    g.endTextTruncated = void 0;
     g.lastError = g.endError;
     g.endError = void 0;
     g.sessionFile = sessionFileOf(c).sessionFile;
@@ -1693,6 +2449,8 @@ function serveCtl(pi) {
     });
   }
   function command(req) {
+    const stale = incarnationRefusal(req);
+    if (stale) return stale;
     const name = CTL_COMMANDS.find((n) => n === req.name);
     if (name === void 0) {
       return fail(`command must be one of ${CTL_COMMANDS.join(", ")}`);
@@ -1718,8 +2476,12 @@ function serveCtl(pi) {
     });
   }
   function fresh(req) {
+    const stale = incarnationRefusal(req, "expectIncarnation");
+    if (stale) return stale;
     const text = str(req, "text");
     if (text === void 0) return fail("fresh needs a string text");
+    const id = msgIdOf(req);
+    if (id.error) return fail(id.error);
     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");
@@ -1730,6 +2492,7 @@ function serveCtl(pi) {
         armed: false,
         settle: (r) => {
           clearTimeout(timer);
+          if (r.ok) remember(id.id, r.runs ?? g.runs);
           resolve(r);
         }
       };
@@ -1738,6 +2501,17 @@ function serveCtl(pi) {
       ).catch((e) => settleFresh(fail(e instanceof Error ? e.message : String(e))));
     });
   }
+  function incarnationRefusal(req, key = "expectIncarnation") {
+    if (!(key in req) || req[key] === g.incarnation) return void 0;
+    return { ...fail(INCARNATION_MISMATCH), incarnation: g.incarnation };
+  }
+  function msgIdOf(req) {
+    if (!("msgId" in req)) return {};
+    const id = req.msgId;
+    if (typeof id === "string" && id.length >= 1 && id.length <= CTL_MSGID_MAX_LENGTH)
+      return { id };
+    return { error: `msgId must be a string of 1-${CTL_MSGID_MAX_LENGTH} characters` };
+  }
   async function handle(req, conn) {
     switch (req.op) {
       case "hello":
@@ -1747,18 +2521,31 @@ function serveCtl(pi) {
           agent: process.env.MU_AGENT_NAME,
           workstream: process.env.MU_WORKSTREAM,
           piVersion,
+          incarnation: g.incarnation,
           ops: [...CTL_OPS],
+          features: [...CTL_FEATURES],
           ...EXT_VERSION !== void 0 ? { extVersion: EXT_VERSION } : {}
         };
-      case "status":
-        return { v: V, ok: true, ...status() };
+      case "status": {
+        const id = msgIdOf(req);
+        if (id.error) return fail(id.error);
+        if (id.id === void 0) return { v: V, ok: true, ...status() };
+        const got = g.accepted.get(id.id);
+        const msg = got ? { id: id.id, accepted: true, ...got } : { id: id.id, accepted: false };
+        return { v: V, ok: true, ...status(), msg };
+      }
       case "send": {
+        const stale = incarnationRefusal(req);
+        if (stale) return stale;
         const text = str(req, "text");
         if (text === void 0) return fail("send needs a string text");
+        const id = msgIdOf(req);
+        if (id.error) return fail(id.error);
         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 });
+        remember(id.id, before.runs);
         return { v: V, ok: true, ...before };
       }
       case "fresh":
@@ -1766,6 +2553,9 @@ function serveCtl(pi) {
       case "command":
         return command(req);
       case "wait":
+        if ("incarnation" in req && req.incarnation !== g.incarnation) {
+          return { ...fail(INCARNATION_MISMATCH), incarnation: g.incarnation };
+        }
         return wait(
           num(req, "afterRuns"),
           num(req, "timeoutMs"),
@@ -1786,8 +2576,12 @@ function serveCtl(pi) {
     }
   }
   async function interrupt(req, conn) {
+    const stale = incarnationRefusal(req);
+    if (stale) return stale;
     const text = str(req, "text");
     if (text === void 0) return fail("interrupt needs a string text");
+    const id = msgIdOf(req);
+    if (id.error) return fail(id.error);
     const wasBusy = !(g.ctx?.isIdle() ?? g.state === "idle");
     const { pending } = status();
     if (wasBusy) {
@@ -1799,10 +2593,12 @@ function serveCtl(pi) {
     }
     const before = status();
     await g.pi.sendUserMessage(text);
+    remember(id.id, before.runs);
     return { v: V, ok: true, ...before, pending, wasBusy };
   }
   const settledRun = () => ({
     lastText: g.lastText,
+    ...g.lastTextTruncated === true ? { lastTextTruncated: true } : {},
     ...g.lastError !== void 0 ? { lastError: g.lastError } : {},
     ...g.sessionFile !== void 0 ? { sessionFile: g.sessionFile } : {}
   });
@@ -1926,8 +2722,8 @@ function serveCtl(pi) {
     await bind();
   });
   pi.on("session_shutdown", async (e) => {
-    const reason = reasonOf(e);
-    if (reason === "new" || reason === "resume" || reason === "fork" || reason === "reload") {
+    const reason2 = reasonOf(e);
+    if (reason2 === "new" || reason2 === "resume" || reason2 === "fork" || reason2 === "reload") {
       return;
     }
     const s = g.server;
@@ -1957,7 +2753,6 @@ export {
   isUiBlocked,
   lastAssistantError,
   lastAssistantText,
-  promptsDir,
   uiBlocked
 };
 //# sourceMappingURL=mu-pi.js.map