@mu-crew/mu 3.6.2 → 3.7.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Database } from 'better-sqlite3';
 
-type CtlState = "busy" | "idle" | "needs_input";
+type CtlState = "busy" | "idle";
 /** Session commands the `command` op runs: `/new`, `/reload`, `/compact`. */
 declare const CTL_COMMANDS: readonly ["new", "reload", "compact"];
 type CtlCommandName = (typeof CTL_COMMANDS)[number];
@@ -20,6 +20,8 @@ interface StateReading {
     /** ctl only: pi holds queued messages, so an idle reading is about to
      *  turn busy. */
     pending?: boolean;
+    /** ctl only: pi's settled-run count (`mu agent wait --after-runs`). */
+    runs?: number;
 }
 interface StateAgentRef {
     name: string;
@@ -1463,7 +1465,10 @@ type SpawnedAgent = AgentRow & {
  *   4. setPaneTitle + enableMuPaneBordersForPane.
  *   5. finalizeAgentRow() — patch placeholder pane_id to real (workspace
  *      path), or insert a fresh agent row (no-workspace path).
- *   6. awaitSpawnLiveness().
+ *   6. Liveness: awaitSpawnLiveness() (fixed sleep, then pane + scan
+ *      check), or for a tmux pi agent the ctl handshake with a pane
+ *      check per tick and the scan at the end. herdr: startAgentInPane.
+ *   7. ctl handshake for herdr pi agents (outside the rollback).
  *
  * Failure between any of (3)–(6) calls rollbackSpawn() to undo the
  * pane + row + workspace. The caller-visible error is preserved.
@@ -1648,7 +1653,9 @@ declare class AgentDiedOnSpawnError extends Error implements HasNextSteps {
     readonly remote: boolean;
     constructor(agentName: string, paneId: string, scrollback: string | undefined, 
     /** The command the pane ran; an `ssh ...` command gets remote hints. */
-    command?: string | undefined);
+    command?: string | undefined, 
+    /** When it died; default `within <MU_SPAWN_LIVENESS_MS>ms of spawn`. */
+    when?: string);
     errorNextSteps(): NextStep[];
 }
 /**
@@ -1694,7 +1701,9 @@ declare class AgentSpawnStartupError extends Error implements HasNextSteps {
     matchedLine: string, 
     /** Full captured scrollback (tail-trimmed already by
      *  awaitSpawnLiveness). Attached to the message for context. */
-    scrollback: string);
+    scrollback: string, 
+    /** When it was seen; default `within <MU_SPAWN_LIVENESS_MS>ms of spawn`. */
+    when?: string);
     errorNextSteps(): NextStep[];
 }
 /**
@@ -1921,6 +1930,13 @@ type Transport = "ctl" | "mux";
 type SendResult = {
     transport: Transport;
     state?: CtlState;
+    /**
+     * ctl only: pi's completed-run count. For a plain send it is measured
+     * before dispatch (the `mu agent wait --after-runs` baseline); for
+     * `--fresh` it is the new session's count once its run started.
+     * Absent from an extension that predates it.
+     */
+    runs?: number;
     /** Set when the text ran as a pi session command over ctl. */
     command?: CtlCommandName;
 };

package/dist/index.js

@@ -12,7 +12,7 @@ import { execa as execa3 } from "execa";
 
 // src/agents/transport.ts
 import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 
 // src/ctl/client.ts
 import { createConnection } from "net";
@@ -144,6 +144,7 @@ async function ctlProbe(sock, timeoutMs = CTL_DEFAULT_TIMEOUT_MS) {
 
 // src/ctl/path.ts
 import { createHash } from "crypto";
+import { rmSync } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
 
 // src/db.ts
@@ -854,6 +855,13 @@ function ctlSocketPath(workstream, agent, stateDir) {
   const base = stateDir ?? (dbPath ? dirname2(dbPath) : defaultStateDir());
   return sockPathUnder(join2(base, "sock"), workstream, agent);
 }
+function unlinkCtlSocket(db, name, workstream) {
+  if (db.memory) return;
+  try {
+    rmSync(ctlSocketPath(workstream, name, dirname2(db.name)), { force: true });
+  } catch {
+  }
+}
 
 // src/mux.ts
 var mux_exports = {};
@@ -2254,13 +2262,12 @@ function resetMux() {
 // src/agents/spawn.ts
 import { execFile as execFile2 } from "child_process";
 import { mkdirSync as mkdirSync2, rmSync as rmSync4 } from "fs";
-import { basename, dirname as dirname5 } from "path";
+import { basename, dirname as dirname6 } from "path";
 import { setTimeout as delay } from "timers/promises";
 import { promisify as promisify2 } from "util";
 
 // src/agents.ts
-import { rmSync as rmSync3 } from "fs";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 
 // src/glyphs.ts
 var AGENT_STATE_GLYPH = {
@@ -2856,7 +2863,7 @@ function workspacesRoot(workstream) {
 }
 
 // src/workspace/crud.ts
-import { existsSync as existsSync6, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync6, rmSync as rmSync3 } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve3 } from "path";
 
@@ -2866,7 +2873,7 @@ import { resolve as resolve2 } from "path";
 
 // src/vcs/helpers.ts
 import { execFile } from "child_process";
-import { existsSync, rmSync } from "fs";
+import { existsSync, rmSync as rmSync2 } from "fs";
 import { mkdir } from "fs/promises";
 import { dirname as dirname3 } from "path";
 import { promisify } from "util";
@@ -2972,7 +2979,7 @@ async function ensureParent(path) {
 }
 function rmDirSync(path) {
   if (!existsSync(path)) return false;
-  rmSync(path, { recursive: true, force: true });
+  rmSync2(path, { recursive: true, force: true });
   return true;
 }
 async function run(bin, args, cwd) {
@@ -3797,7 +3804,7 @@ async function createWorkspace(db, opts) {
     created = await backend.createWorkspace(createOpts);
   } catch (err) {
     try {
-      rmSync2(path, { recursive: true, force: true });
+      rmSync3(path, { recursive: true, force: true });
     } catch {
     }
     throw err;
@@ -4438,8 +4445,17 @@ var CycleError = class extends Error {
     ];
   }
 };
+function stallWaitHint(owner, ws, runs) {
+  if (runs === void 0 || runs < 1) return [];
+  return [
+    {
+      intent: "Read the worker's last answer (its final text, at once)",
+      command: `mu agent wait ${owner} --after-runs ${runs - 1} --json -w ${ws}`
+    }
+  ];
+}
 var StallDetectedDuringWaitError = class extends Error {
-  constructor(taskName, owner, workstream, ageSecs, ownerExpectsCtl = false) {
+  constructor(taskName, owner, workstream, ageSecs, ownerExpectsCtl = false, ownerRuns) {
     const ownerBit = owner !== null ? owner : "<unknown>";
     super(
       `task ${taskName} owned by ${ownerBit} has been needs_input for ${ageSecs}s; exiting per --on-stall exit. Read the pane to see which it is \u2014 finished without closing, waiting on an answer, or sitting at a prompt.`
@@ -4449,12 +4465,14 @@ var StallDetectedDuringWaitError = class extends Error {
     this.workstream = workstream;
     this.ageSecs = ageSecs;
     this.ownerExpectsCtl = ownerExpectsCtl;
+    this.ownerRuns = ownerRuns;
   }
   taskName;
   owner;
   workstream;
   ageSecs;
   ownerExpectsCtl;
+  ownerRuns;
   name = "StallDetectedDuringWaitError";
   /**
    * Diagnose before acting. `mu agent read` comes FIRST because the
@@ -4469,6 +4487,7 @@ var StallDetectedDuringWaitError = class extends Error {
     const ws = this.workstream;
     const ownerBit = this.owner !== null ? this.owner : "<owner>";
     return [
+      ...stallWaitHint(ownerBit, ws, this.ownerRuns),
       {
         intent: "Read the worker's pane to see what it is waiting on",
         command: `mu agent read ${ownerBit} -w ${ws} --lines 60`
@@ -4822,7 +4841,7 @@ function reparentTaskImpl(db, taskLocalId, blockers, scope) {
 
 // src/workstream.ts
 import { existsSync as existsSync7, readdirSync as readdirSync2, rmdirSync } from "fs";
-import { join as join5 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 var WORKSTREAM_NAME_RE = /^[a-z][a-z0-9_-]{0,31}$/;
 var RESERVED_WORKSTREAM_PREFIX = "mu-";
 var RESERVED_WORKSTREAM_NAMES = /* @__PURE__ */ new Set(["scratch"]);
@@ -4936,6 +4955,7 @@ async function teardownWorkstream(db, opts) {
   const notesBefore = countNotes(db, opts.workstream);
   const edgesBefore = countEdges(db, opts.workstream);
   const workspacesBefore = listWorkspaces2(db, opts.workstream);
+  const agentNames = listAgentNames(db, opts.workstream);
   const mux = await activeMux();
   const muxAliveBefore = await mux.sessionExists(muxSession);
   if (muxAliveBefore) {
@@ -4973,6 +4993,14 @@ async function teardownWorkstream(db, opts) {
     } catch {
     }
   }
+  for (const name of agentNames) unlinkCtlSocket(db, name, opts.workstream);
+  if (!db.memory) {
+    const sockDir = join5(dirname4(db.name), "sock", opts.workstream);
+    try {
+      if (readdirSync2(sockDir).length === 0) rmdirSync(sockDir);
+    } catch {
+    }
+  }
   withOpContext(
     db,
     { intent: "workstream.teardown", group: "new" },
@@ -4989,6 +5017,14 @@ async function teardownWorkstream(db, opts) {
     failedWorkspaces
   };
 }
+function listAgentNames(db, workstream) {
+  const rows = db.prepare(
+    `SELECT a.name FROM agents a
+         JOIN workstreams ws ON ws.id = a.workstream_id
+        WHERE ws.name = ?`
+  ).all(workstream);
+  return rows.map((r) => r.name);
+}
 function countAgents(db, workstream) {
   const row = db.prepare(
     `SELECT COUNT(*) AS n FROM agents a
@@ -5601,12 +5637,15 @@ async function waitForTasks(db, input, opts) {
   const ctlBrokenSince = /* @__PURE__ */ new Map();
   const stuckLabel = /* @__PURE__ */ new Map();
   const ctlOwners = /* @__PURE__ */ new Set();
+  const ownerRuns = /* @__PURE__ */ new Map();
   const stuckAgeMs = async (status, owner, workstreamName) => {
     if (stuckAfterMs <= 0 || status !== "IN_PROGRESS" || owner === null || opts.readOwnerState === void 0)
       return null;
     const reading = await opts.readOwnerState({ name: owner, workstreamName });
     const ownerKey = `${workstreamName}/${owner}`;
     if (reading?.ctl !== void 0) ctlOwners.add(ownerKey);
+    if (reading?.runs !== void 0) ownerRuns.set(ownerKey, reading.runs);
+    else ownerRuns.delete(ownerKey);
     if (reading?.alive === true && (reading.ctl === "missing" || reading.ctl === "refused")) {
       const firstSeen = ctlBrokenSince.get(ownerKey) ?? Date.now();
       ctlBrokenSince.set(ownerKey, firstSeen);
@@ -5636,10 +5675,13 @@ async function waitForTasks(db, input, opts) {
         stuckWarned.add(key);
         const ageSecs = Math.round(ageMs / 1e3);
         const ownerBit = owner ?? "<none>";
+        const runs = ownerRuns.get(`${ref.workstreamName}/${ownerBit}`);
         const stateBit = stuckLabel.get(`${ref.workstreamName}/${ownerBit}`) ?? "needs_input";
+        const waitLine = stallWaitHint(ownerBit, ref.workstreamName, runs).map((s) => `  ${s.command}
+`).join("");
         currentStuckWarn(
           `\x1B[33mmu task wait: ${key} needs attention \u2014 owner=${ownerBit} has been in ${stateBit} for ${formatStallAge(ageMs)}. It may have finished without closing, be waiting on an answer, or be sitting at a prompt.\x1B[0m
-  mu agent read ${ownerBit} -w ${ref.workstreamName} --lines 60
+` + waitLine + `  mu agent read ${ownerBit} -w ${ref.workstreamName} --lines 60
 `
         );
         emitEvent(
@@ -5655,7 +5697,8 @@ async function waitForTasks(db, input, opts) {
             owner,
             ref.workstreamName,
             ageSecs,
-            ctlOwners.has(`${ref.workstreamName}/${owner ?? ""}`)
+            ctlOwners.has(`${ref.workstreamName}/${owner ?? ""}`),
+            runs
           );
         }
       }
@@ -6089,13 +6132,6 @@ function deleteAgent(db, name, workstream) {
   if (deleted) unlinkCtlSocket(db, name, workstream);
   return deleted;
 }
-function unlinkCtlSocket(db, name, workstream) {
-  if (db.memory) return;
-  try {
-    rmSync3(ctlSocketPath(workstream, name, dirname4(db.name)), { force: true });
-  } catch {
-  }
-}
 function deleteAgentRow(db, name, workstream) {
   return withOpContext(
     db,
@@ -6191,7 +6227,7 @@ async function listLiveAgents(db, opts) {
     ...opts.mode !== void 0 ? { mode: opts.mode } : {}
   });
   const baseAgents = listAgents(db, { workstream: opts.workstream });
-  const readings = await readAgentStates(baseAgents, { stateDir: dirname4(db.name) });
+  const readings = await readAgentStates(baseAgents, { stateDir: dirname5(db.name) });
   const now = Date.now();
   const agents = baseAgents.map((agent) => {
     const reading = readings.get(agentKey(agent)) ?? {
@@ -6456,7 +6492,7 @@ function defaultSpawnCtlMs() {
   return parsed;
 }
 var CTL_POLL_INTERVAL_MS = 250;
-async function awaitCtlHandshake(sock) {
+async function awaitCtlHandshake(sock, onMiss) {
   const budgetMs = defaultSpawnCtlMs();
   const deadline = Date.now() + budgetMs;
   for (; ; ) {
@@ -6464,6 +6500,7 @@ async function awaitCtlHandshake(sock) {
     const probe = await ctlProbe(sock, Math.max(1, Math.min(remaining, CTL_POLL_INTERVAL_MS * 4)));
     if (probe.kind === "ok") return "ok";
     const last = probeToSpawnCtl(probe.kind);
+    if (onMiss) await onMiss();
     const left = deadline - Date.now();
     if (left <= 0) return last;
     await delay(Math.min(CTL_POLL_INTERVAL_MS, left));
@@ -6491,8 +6528,8 @@ async function spawnAgent(db, opts) {
     }
   }
   const workspacePathStr = opts.workspace ? await prestageWorkspace(db, opts, cli) : void 0;
-  const ctlSocket = ctlSocketPath(opts.workstream, opts.name, dirname5(db.name));
-  mkdirSync2(dirname5(ctlSocket), { recursive: true, mode: 448 });
+  const ctlSocket = ctlSocketPath(opts.workstream, opts.name, dirname6(db.name));
+  mkdirSync2(dirname6(ctlSocket), { recursive: true, mode: 448 });
   rmSync4(ctlSocket, { force: true });
   const paneEnv = {
     MU_MANAGED_AGENT: "1",
@@ -6503,6 +6540,8 @@ async function spawnAgent(db, opts) {
   const hasWorkspace = workspacePathStr !== void 0;
   let paneId;
   let agent;
+  const wantsCtl = opts.ctl !== false && speaksMuCtl(cli, command) && defaultSpawnCtlMs() !== 0;
+  let ctl;
   try {
     const created = await withSpawnLock(session, async () => {
       const pid = await createOrReusePane({
@@ -6523,7 +6562,23 @@ async function spawnAgent(db, opts) {
     agent = created.row;
     const startAgent = (await activeMux()).startAgentInPane;
     if (startAgent === void 0) {
-      await awaitSpawnLiveness(paneId, opts.name, command);
+      if (wantsCtl) {
+        const pid = paneId;
+        const check = defaultSpawnLivenessMs() !== 0;
+        const when = `during the ctl handshake (up to ${defaultSpawnCtlMs()}ms after spawn)`;
+        let lastScrollback;
+        const assertPaneAlive = async () => {
+          const mux = await activeMux();
+          const sb = await mux.capturePane(pid, { lines: 50 }).catch(() => void 0);
+          lastScrollback = sb ?? lastScrollback;
+          if (await mux.paneExists(pid)) return;
+          throw new AgentDiedOnSpawnError(opts.name, pid, lastScrollback, command, when);
+        };
+        ctl = await awaitCtlHandshake(ctlSocket, check ? assertPaneAlive : void 0);
+        if (check) await checkSpawnHealth(pid, opts.name, command, when);
+      } else {
+        await awaitSpawnLiveness(paneId, opts.name, command);
+      }
     } else {
       await startAgent({ paneId, name: opts.name, cli, command, commandSource });
     }
@@ -6532,14 +6587,13 @@ async function spawnAgent(db, opts) {
     if (hasWorkspace) attachOrphanCleanupHint(err, opts.name, opts.workstream);
     throw err;
   }
-  const ctl = opts.ctl === false || !speaksMuCtl(cli, command) || defaultSpawnCtlMs() === 0 ? "skipped" : await awaitCtlHandshake(ctlSocket);
+  ctl ??= wantsCtl ? await awaitCtlHandshake(ctlSocket) : "skipped";
   emitEvent(
     db,
     opts.workstream,
     "agent.spawn",
     `agent spawn ${opts.name} (cli=${cli}, role=${opts.role ?? "full-access"}, pane=${paneId})`
   );
-  await refreshAgentTitle(db, opts.name, opts.workstream);
   maybeWarnNonConventionalAgentName(opts.name);
   return { ...agent, ctl, ctlSocket };
 }
@@ -6667,15 +6721,18 @@ async function awaitSpawnLiveness(paneId, agentName, command) {
   const ms = defaultSpawnLivenessMs();
   if (ms === 0) return;
   await sleep(ms);
+  await checkSpawnHealth(paneId, agentName, command);
+}
+async function checkSpawnHealth(paneId, agentName, command, when) {
   const mux = await activeMux();
   const scrollback = await mux.capturePane(paneId, { lines: 50 }).catch(() => void 0);
   if (!await mux.paneExists(paneId)) {
-    throw new AgentDiedOnSpawnError(agentName, paneId, scrollback, command);
+    throw new AgentDiedOnSpawnError(agentName, paneId, scrollback, command, when);
   }
   if (scrollback !== void 0) {
     const matchedLine = detectSpawnStartupError(scrollback);
     if (matchedLine !== void 0) {
-      throw new AgentSpawnStartupError(agentName, paneId, matchedLine, scrollback);
+      throw new AgentSpawnStartupError(agentName, paneId, matchedLine, scrollback, when);
     }
   }
 }
@@ -6830,7 +6887,7 @@ var AgentNotInWorkstreamError = class extends Error {
   }
 };
 var AgentDiedOnSpawnError = class extends Error {
-  constructor(agentName, paneId, scrollback, command) {
+  constructor(agentName, paneId, scrollback, command, when = `within ${defaultSpawnLivenessMs()}ms of spawn`) {
     const tail = scrollback?.trim();
     const detail = tail ? `
 
@@ -6839,9 +6896,7 @@ ${tail}
 --- end scrollback ---` : "";
     const remote = /^\s*ssh\s/.test(command ?? "");
     const cause = remote ? 'The command is an ssh hop, so the likely causes are remote: the remote binary is missing, or its env (PATH, provider keys) is absent because ssh runs a non-interactive shell that skips ~/.zshrc / ~/.bashrc (wrap it: $SHELL -ilc "pi --approve"); or sshd refused the socket forward (ExitOnForwardFailure=yes kills the connection; check AllowStreamLocalForwarding).' : "Most common cause: the spawned CLI exited immediately (e.g. a wrapper CLI blocking on its instance lock; set MU_<UPPER_CLI>_COMMAND to a non-blocking variant to bypass).";
-    super(
-      `agent ${agentName} died within ${defaultSpawnLivenessMs()}ms of spawn (pane ${paneId}). ${cause}${detail}`
-    );
+    super(`agent ${agentName} died ${when} (pane ${paneId}). ${cause}${detail}`);
     this.agentName = agentName;
     this.paneId = paneId;
     this.scrollback = scrollback;
@@ -6900,9 +6955,9 @@ ${tail}
   }
 };
 var AgentSpawnStartupError = class extends Error {
-  constructor(agentName, paneId, matchedLine, scrollback) {
+  constructor(agentName, paneId, matchedLine, scrollback, when = `within ${defaultSpawnLivenessMs()}ms of spawn`) {
     super(
-      `agent ${agentName} reported a startup error within ${defaultSpawnLivenessMs()}ms of spawn (pane ${paneId}). The pane is alive but the spawned CLI parked at an error prompt instead of becoming a working agent.
+      `agent ${agentName} reported a startup error ${when} (pane ${paneId}). The pane is alive but the spawned CLI parked at an error prompt instead of becoming a working agent.
 
 Matched line: ${matchedLine.trim()}
 
@@ -6988,7 +7043,14 @@ var AgentCtlUnreachableError = class extends Error {
   kind;
   name = "AgentCtlUnreachableError";
   errorNextSteps() {
+    const trust = this.kind === "missing" ? [
+      {
+        intent: "Just spawned? pi may sit at its project trust prompt: answer /trust in the pane, or respawn with --command 'pi --approve'",
+        command: `mu agent read ${this.agentName} -w ${this.workstream}`
+      }
+    ] : [];
     return [
+      ...trust,
       { intent: "Check whether the mu pi extension is linked", command: "mu doctor" },
       {
         intent: "Stop a runaway tool without the socket",
@@ -7071,7 +7133,7 @@ var AgentFreshNeedsCtlError = class extends Error {
   }
 };
 var AgentExtensionOutdatedError = class extends Error {
-  constructor(agentName, workstream, op, extVersion) {
+  constructor(agentName, workstream, op, extVersion, ops) {
     super(
       `agent ${agentName}'s mu pi extension (${extVersion ?? "version unknown"}) predates op ${op}: its pi loaded an older mu build; reload or respawn it`
     );
@@ -7079,18 +7141,21 @@ var AgentExtensionOutdatedError = class extends Error {
     this.workstream = workstream;
     this.op = op;
     this.extVersion = extVersion;
+    this.ops = ops;
   }
   agentName;
   workstream;
   op;
   extVersion;
+  ops;
   name = "AgentExtensionOutdatedError";
   errorNextSteps() {
     const w = `-w ${this.workstream}`;
+    const via = this.ops?.includes("command") ? "" : " --via mux";
     return [
       {
-        intent: "Reload pi's extensions in the pane (keeps the session and context)",
-        command: `mu agent send ${this.agentName} '/reload' --via mux ${w}`
+        intent: "Reload pi's extensions (keeps the session and context)",
+        command: `mu agent send ${this.agentName} '/reload'${via} ${w}`
       },
       {
         intent: "Or respawn the agent (loses its context)",
@@ -7148,7 +7213,7 @@ var AgentSlashCommandUnsupportedError = class extends Error {
 
 // src/agents/transport.ts
 function agentCtlSocket(db, agent) {
-  return ctlSocketPath(agent.workstreamName, agent.name, dirname6(db.name));
+  return ctlSocketPath(agent.workstreamName, agent.name, dirname7(db.name));
 }
 function expectsCtl(agent, sock = ctlSocketPath(agent.workstreamName, agent.name)) {
   return speaksMuCtl(agent.cli, resolveCliCommand(agent.cli)) || existsSync8(sock);
@@ -7176,7 +7241,7 @@ async function extensionOutdated(agent, sock, e) {
     if (hello.ok) extVersion = hello.extVersion;
   } catch {
   }
-  return new AgentExtensionOutdatedError(agent.name, agent.workstreamName, e.op, extVersion);
+  return new AgentExtensionOutdatedError(agent.name, agent.workstreamName, e.op, extVersion, e.ops);
 }
 async function ctlRequestFor(agent, sock, req) {
   try {
@@ -7225,7 +7290,11 @@ async function sendViaTransport(agent, text, opts) {
     }
     throw new Error(`control socket refused the send: ${reply.error}`);
   }
-  return reply.state === void 0 ? { transport } : { transport, state: reply.state };
+  return {
+    transport,
+    ...reply.state !== void 0 ? { state: reply.state } : {},
+    ...reply.runs !== void 0 ? { runs: reply.runs } : {}
+  };
 }
 async function runSessionCommand(agent, sock, cmd, force) {
   const reply = await ctlRequestFor(agent, sock, {
@@ -7427,7 +7496,8 @@ async function readAgentStates(agents, opts = {}) {
         since: probe.status.since,
         alive: true,
         ctl: "ok",
-        pending: probe.status.pending
+        pending: probe.status.pending,
+        runs: probe.status.runs
       });
     } else {
       failed.set(agentKey(agent), probe?.kind === "missing" ? "missing" : "refused");
@@ -8078,7 +8148,7 @@ function formatTreeNodeLabel(t, statusFn, opts = {}) {
 
 // src/doctor-summary.ts
 import { accessSync as accessSync2, constants as constants2, existsSync as existsSync13, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "fs";
-import { delimiter as delimiter2, dirname as dirname9, join as join11, parse } from "path";
+import { delimiter as delimiter2, dirname as dirname10, join as join11, parse } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/drift.ts
@@ -8088,7 +8158,7 @@ import { join as join9 } from "path";
 
 // src/rebuild.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync3, statSync } from "fs";
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 var RebuildTargetExistsError = class extends Error {
   constructor(path) {
     super(`rebuild target already exists: ${path}`);
@@ -8151,7 +8221,7 @@ function rebuildInto(source, opts) {
   if (existsSync10(targetPath) && opts.force !== true) {
     throw new RebuildTargetExistsError(targetPath);
   }
-  mkdirSync3(dirname7(targetPath), { recursive: true });
+  mkdirSync3(dirname8(targetPath), { recursive: true });
   const identity = source.prepare(
     "SELECT machine_id, hostname, created_at, last_wall, last_counter FROM machine_identity WHERE id = 1"
   ).get();
@@ -8673,7 +8743,7 @@ import {
   writeFileSync
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname8, join as join10, resolve as resolve5 } from "path";
+import { dirname as dirname9, join as join10, resolve as resolve5 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 var MU_SHIM_MARKER = "// mu:shim";
 var LinkConflictError = class extends Error {
@@ -8703,7 +8773,7 @@ function resolveHome(opts) {
   return opts?.home ?? process.env.MU_PI_HOME ?? homedir4();
 }
 function packageRoot() {
-  return resolve5(dirname8(fileURLToPath(import.meta.url)), "..");
+  return resolve5(dirname9(fileURLToPath(import.meta.url)), "..");
 }
 function extensionEntry() {
   return process.env.MU_EXTENSION_ENTRY ?? join10(packageRoot(), "dist", "extension", "mu-pi.js");
@@ -8739,7 +8809,7 @@ function linkPi(opts) {
     replacedCopy = !readFileSync(path, "utf8").includes(MU_SHIM_MARKER);
   } catch {
   }
-  mkdirSync4(dirname8(path), { recursive: true });
+  mkdirSync4(dirname9(path), { recursive: true });
   writeFileSync(path, opts?.copy === true ? readFileSync(entry, "utf8") : shim(entry));
   return { path, replacedCopy };
 }
@@ -8750,7 +8820,7 @@ function linkSkill(opts) {
   const st = lstatOrUndefined(path);
   if (st) {
     if (!st.isSymbolicLink()) throw new LinkConflictError(path, "not-a-symlink");
-    const current = resolve5(dirname8(path), readlinkSync(path));
+    const current = resolve5(dirname9(path), readlinkSync(path));
     if (current === target) return { path, target };
     if (existsSync12(current) && opts?.force !== true) {
       throw new LinkConflictError(path, "foreign-symlink", current);
@@ -8758,7 +8828,7 @@ function linkSkill(opts) {
     previous = current;
     rmSync6(path);
   }
-  mkdirSync4(dirname8(path), { recursive: true });
+  mkdirSync4(dirname9(path), { recursive: true });
   symlinkSync(target, path, "dir");
   return previous === void 0 ? { path, target } : { path, target, previous };
 }
@@ -8792,7 +8862,7 @@ function inspectSkill(path) {
   try {
     target = realpathSync(path);
   } catch {
-    return { path, state: "dangling", target: resolve5(dirname8(path), readlinkSync(path)) };
+    return { path, state: "dangling", target: resolve5(dirname9(path), readlinkSync(path)) };
   }
   let skillMd;
   try {
@@ -8971,7 +9041,7 @@ function resolveExecutable(name) {
   return null;
 }
 function murmurVersion(executable) {
-  let dir = dirname9(executable);
+  let dir = dirname10(executable);
   const root = parse(dir).root;
   while (dir !== root) {
     const packagePath = join11(dir, "package.json");
@@ -8984,7 +9054,7 @@ function murmurVersion(executable) {
       } catch {
       }
     }
-    dir = dirname9(dir);
+    dir = dirname10(dir);
   }
   return null;
 }
@@ -9020,7 +9090,7 @@ function murmurDoctorCheck(agentStateSource, opts = {}) {
     return {
       name: "murmur",
       status: "warn",
-      detail: `murmur ${version} is older than 1.0.0; @murmur_pane_since missing, idle/stall timing unknown`
+      detail: opts.muExtOk === true ? `murmur ${version} is older than 1.0.0; idle/stall timing unknown for non-pi CLIs (pi agents use ctl)` : `murmur ${version} is older than 1.0.0; @murmur_pane_since missing, idle/stall timing unknown`
     };
   }
   return {
@@ -9129,11 +9199,14 @@ function remediationParagraph(check) {
       return [
         "mu talks to pi agents over a per-agent control socket served by",
         "the mu pi extension. `missing`: no socket (extension not loaded,",
-        "or the agent predates `mu link pi`). `refused`: socket present but",
-        "not answering. `version`: protocol mismatch; upgrade mu or pi.",
+        "the agent predates `mu link pi`, or a new pi still waits at its",
+        "project trust prompt: answer /trust in the pane, or spawn with",
+        "--command 'pi --approve'). `refused`: socket present but not",
+        "answering. `version`: protocol mismatch; upgrade mu or pi.",
         "Run `mu link pi`, then respawn the agent. `extension X older than",
-        "installed Y`: the agent's pi loaded an older mu build; type /reload",
-        "in its pane (`mu agent send <a> '/reload' --via mux`) or respawn it."
+        "installed Y` or `lacks ops`: the agent's pi loaded an older mu",
+        "build; reload it with `mu agent send <a> '/reload'` (add",
+        "`--via mux` when the extension lacks op command) or respawn it."
       ];
     case "agents":
       return [