@mu-crew/mu 3.6.2 → 3.8.0

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";
@@ -68,7 +68,7 @@ var CtlUnknownOpError = class extends Error {
 function clientTimeout(req, override) {
   if (override !== void 0) return override;
   if (req.op === "fresh" || req.op === "command") return CTL_FRESH_TIMEOUT_MS;
-  if (req.op !== "wait") return CTL_DEFAULT_TIMEOUT_MS;
+  if (req.op !== "wait" && req.op !== "interrupt") return CTL_DEFAULT_TIMEOUT_MS;
   return req.timeoutMs === void 0 ? void 0 : req.timeoutMs + CTL_WAIT_SLACK_MS;
 }
 function parseReply(line) {
@@ -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,285 +855,598 @@ function ctlSocketPath(workstream, agent, stateDir) {
   const base = stateDir ?? (dbPath ? dirname2(dbPath) : defaultStateDir());
   return sockPathUnder(join2(base, "sock"), workstream, agent);
 }
-
-// src/mux.ts
-var mux_exports = {};
-__export(mux_exports, {
-  HerdrCommandOverrideError: () => HerdrCommandOverrideError,
-  HerdrError: () => HerdrError,
-  HerdrNotImplementedError: () => HerdrNotImplementedError,
-  HerdrSyntaxError: () => HerdrSyntaxError,
-  HerdrUnsupportedCliError: () => HerdrUnsupportedCliError,
-  HerdrWorkspaceGroupCloseError: () => HerdrWorkspaceGroupCloseError,
-  MuxError: () => MuxError,
-  NoMultiplexerError: () => NoMultiplexerError,
-  PaneNotFoundError: () => PaneNotFoundError,
-  activeMux: () => activeMux,
-  detectMux: () => detectMux,
-  herdrBackend: () => herdrBackend,
-  isHerdrStatusUsable: () => isHerdrStatusUsable,
-  muxByName: () => muxByName,
-  parseAgentNameFromTitle: () => parseAgentNameFromTitle,
-  resetHerdrExecutor: () => resetHerdrExecutor,
-  resetMux: () => resetMux,
-  setHerdrExecutor: () => setHerdrExecutor,
-  setMuxForTests: () => setMuxForTests,
-  tmuxBackend: () => tmuxBackend
-});
-
-// src/mux/herdr.ts
-import { execa as execa2 } from "execa";
-
-// src/mux/tmux.ts
-import { execa } from "execa";
-
-// src/mux/input-timing.ts
-var TAIL_WINDOW_LINES = 100;
-var TAIL_LINES = 20;
-var BUSY_MARKERS = ["to interrupt)"];
-var BRAILLE_SPINNER_RE = /[\u2800-\u28ff]/;
-function extractTail(scrollback) {
-  const lines = scrollback.split("\n");
-  const window = lines.slice(-TAIL_WINDOW_LINES);
-  let end = window.length;
-  while (end > 0 && (window[end - 1] ?? "").trim() === "") end--;
-  return window.slice(Math.max(0, end - TAIL_LINES), end).join("\n");
-}
-function paneLooksBusy(scrollback) {
-  const tail = extractTail(scrollback);
-  return BUSY_MARKERS.some((marker) => tail.includes(marker)) || BRAILLE_SPINNER_RE.test(tail);
+function unlinkCtlSocket(db, name, workstream) {
+  if (db.memory) return;
+  try {
+    rmSync(ctlSocketPath(workstream, name, dirname2(db.name)), { force: true });
+  } catch {
+  }
 }
 
-// src/mux/types.ts
-function parseAgentNameFromTitle(title) {
-  const idx = title.indexOf(" \xB7 ");
-  return idx === -1 ? title.trim() : title.slice(0, idx).trim();
-}
-var MuxError = class extends Error {
-  name = "MuxError";
-  errorNextSteps() {
-    return [{ intent: "Run health check", command: "mu doctor" }];
-  }
-};
-var PaneNotFoundError = class extends Error {
-  constructor(paneId, backend) {
-    super(`${backend?.name ?? "mux"} pane not found: ${paneId}`);
-    this.paneId = paneId;
-    this.backend = backend;
-  }
-  paneId;
-  backend;
-  name = "PaneNotFoundError";
-  errorNextSteps() {
-    return [
-      ...this.backend?.paneNotFoundNextSteps(this.paneId) ?? [],
-      {
-        intent: "List workstreams to choose the right scope",
-        command: "mu workstream list"
-      },
-      {
-        intent: "List registered agents and orphan panes in that scope",
-        command: "mu agent list -w <workstream>"
-      }
-    ];
+// src/logs.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/hlc.ts
+var WALL_WIDTH = 15;
+var COUNTER_WIDTH = 6;
+var SEP = ".";
+var MAX_WALL = 10 ** WALL_WIDTH - 1;
+var MAX_COUNTER = 10 ** COUNTER_WIDTH - 1;
+var HlcParseError = class extends Error {
+  constructor(value) {
+    super(`Malformed HLC: ${JSON.stringify(value)}`);
+    this.value = value;
+    this.name = "HlcParseError";
   }
+  value;
 };
-var NoMultiplexerError = class extends Error {
-  constructor(tried) {
+var HlcOverflowError = class extends Error {
+  constructor(field, value) {
     super(
-      `no supported multiplexer found (tried: ${tried.join(", ")}). mu drives agents through tmux panes.`
+      field === "counter" ? `HLC counter overflow (${value} > ${MAX_COUNTER}): more than ${MAX_COUNTER + 1} ops in one millisecond` : `HLC wall-clock overflow (${value} > ${MAX_WALL}): system clock is far in the future`
     );
-    this.tried = tried;
-  }
-  tried;
-  name = "NoMultiplexerError";
-  errorNextSteps() {
-    return [
-      { intent: "Run health check", command: "mu doctor" },
-      { intent: "Verify tmux is installed", command: "tmux -V" },
-      { intent: "Force a specific backend", command: "MU_MUX=tmux mu <verb>" }
-    ];
+    this.field = field;
+    this.value = value;
+    this.name = "HlcOverflowError";
   }
+  field;
+  value;
 };
-
-// src/mux/tmux.ts
-var TmuxError = class extends MuxError {
-  constructor(args, stderr, stdout, exitCode) {
-    const detail = stderr.trim() || stdout.trim() || "no output";
-    super(`tmux ${args.join(" ")} failed (exit ${exitCode}): ${detail}`);
-    this.args = args;
-    this.stderr = stderr;
-    this.stdout = stdout;
-    this.exitCode = exitCode;
-    this.name = "TmuxError";
-  }
-  args;
-  stderr;
-  stdout;
-  exitCode;
-  errorNextSteps() {
-    return [
-      { intent: "Run health check", command: "mu doctor" },
-      {
-        intent: "Verify tmux is running and reachable",
-        command: "tmux info | head"
-      },
-      {
-        intent: "Check the failing tmux command in isolation",
-        command: `tmux ${this.args.join(" ")}`
-      }
-    ];
+var MachineIdentityMissingError = class extends Error {
+  constructor() {
+    super("machine_identity row (id = 1) is missing; the DB was not opened via openDb()");
+    this.name = "MachineIdentityMissingError";
   }
 };
-var PANE_ID_RE = /^%\d+$/;
-function isValidPaneId(s) {
-  return PANE_ID_RE.test(s);
+function formatHlc(hlc) {
+  const { wallMs, counter, machineId: machineId2 } = hlc;
+  if (!Number.isInteger(wallMs) || wallMs < 0) throw new HlcParseError(String(wallMs));
+  if (!Number.isInteger(counter) || counter < 0) throw new HlcParseError(String(counter));
+  if (wallMs > MAX_WALL) throw new HlcOverflowError("wall", wallMs);
+  if (counter > MAX_COUNTER) throw new HlcOverflowError("counter", counter);
+  if (machineId2.length === 0 || machineId2.includes(SEP)) throw new HlcParseError(machineId2);
+  return `${String(wallMs).padStart(WALL_WIDTH, "0")}${SEP}${String(counter).padStart(
+    COUNTER_WIDTH,
+    "0"
+  )}${SEP}${machineId2}`;
 }
-function assertValidPaneId(s) {
-  if (!isValidPaneId(s)) {
-    throw new TypeError(`invalid tmux pane id: ${JSON.stringify(s)} (expected /^%\\d+$/)`);
+function parseHlc(value) {
+  const parts = value.split(SEP);
+  if (parts.length !== 3) throw new HlcParseError(value);
+  const [wall, counter, machineId2] = parts;
+  if (wall === void 0 || counter === void 0 || machineId2 === void 0) {
+    throw new HlcParseError(value);
   }
+  if (wall.length !== WALL_WIDTH || counter.length !== COUNTER_WIDTH || machineId2.length === 0) {
+    throw new HlcParseError(value);
+  }
+  if (!/^\d+$/.test(wall) || !/^\d+$/.test(counter)) throw new HlcParseError(value);
+  return { wallMs: Number(wall), counter: Number(counter), machineId: machineId2 };
 }
-function defaultSendDelayMs() {
-  const raw = process.env.MU_SEND_DELAY_MS;
-  if (raw === void 0) return 500;
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed < 0) return 500;
-  return parsed;
+function compareHlc(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
 }
-function tmuxGlobalFlags() {
-  const socket = process.env.MU_TMUX_SOCKET;
-  if (socket === void 0 || socket.length === 0) return [];
-  return ["-L", socket, "-f", "/dev/null"];
+function nextHlc(db, now = Date.now()) {
+  const row = db.prepare(
+    `UPDATE machine_identity
+          SET last_wall    = MAX(last_wall, @now),
+              last_counter = CASE WHEN @now > last_wall THEN 0 ELSE last_counter + 1 END
+        WHERE id = 1
+        RETURNING machine_id, last_wall, last_counter`
+  ).get({ now: Math.floor(now) });
+  if (!row) throw new MachineIdentityMissingError();
+  return formatHlc({ wallMs: row.last_wall, counter: row.last_counter, machineId: row.machine_id });
 }
-var realExecutor = async (args) => {
-  const result = await execa("tmux", [...tmuxGlobalFlags(), ...args], { reject: false });
-  return {
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-    exitCode: result.exitCode ?? null
-  };
-};
-var currentExecutor = realExecutor;
-function setTmuxExecutor(executor) {
-  const previous = currentExecutor;
-  currentExecutor = executor;
-  return previous;
+function receiveHlc(db, remoteHlc, now = Date.now()) {
+  const remote = parseHlc(remoteHlc);
+  const wallNow = Math.floor(now);
+  const read = db.prepare(
+    "SELECT machine_id, last_wall, last_counter FROM machine_identity WHERE id = 1"
+  );
+  const write = db.prepare(
+    "UPDATE machine_identity SET last_wall = @wall, last_counter = @counter WHERE id = 1"
+  );
+  const advance = db.transaction(() => {
+    const row = read.get();
+    if (!row) throw new MachineIdentityMissingError();
+    const wall = Math.max(row.last_wall, remote.wallMs, wallNow);
+    const localAtMax = row.last_wall === wall;
+    const remoteAtMax = remote.wallMs === wall;
+    let counter;
+    if (!localAtMax && !remoteAtMax) {
+      counter = 0;
+    } else if (localAtMax && remoteAtMax) {
+      counter = Math.max(row.last_counter, remote.counter) + 1;
+    } else if (localAtMax) {
+      counter = row.last_counter + 1;
+    } else {
+      counter = remote.counter + 1;
+    }
+    if (counter > MAX_COUNTER) throw new HlcOverflowError("counter", counter);
+    write.run({ wall, counter });
+    return formatHlc({ wallMs: wall, counter, machineId: row.machine_id });
+  });
+  return advance.immediate();
 }
-function resetTmuxExecutor() {
-  currentExecutor = realExecutor;
+
+// src/legacy-ops.ts
+var LEGACY_LOG_ONLY_INTENTS = /* @__PURE__ */ new Set(["workstream.export"]);
+function isLegacyLogOnlyIntent(intent) {
+  return intent !== null && LEGACY_LOG_ONLY_INTENTS.has(intent);
 }
-async function tmux(args) {
-  const result = await currentExecutor(args);
-  if (result.exitCode !== 0) {
-    throw new TmuxError([...args], result.stderr, result.stdout, result.exitCode);
-  }
-  return result.stdout;
-}
-var currentSleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
-function setSleepForTests(impl) {
-  const previous = currentSleep;
-  currentSleep = impl;
-  return previous;
+var LEGACY_INTENT_SYNONYMS = /* @__PURE__ */ new Map([
+  ["workstream.teardown", ["workstream.destroy"]]
+]);
+function intentSpellings(intent) {
+  const legacy = LEGACY_INTENT_SYNONYMS.get(intent);
+  return legacy === void 0 ? [intent] : [intent, ...legacy];
 }
-function resetSleep() {
-  currentSleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var LEGACY_LOG_ONLY_SQL_EXCLUSION = `(intent IS NULL OR intent NOT IN (${[
+  ...LEGACY_LOG_ONLY_INTENTS
+].map((i) => `'${i}'`).join(", ")}))`;
+
+// src/logs.ts
+var SELECT_LOG_COLS = `
+  l.seq AS seq,
+  l.key AS workstream,
+  l.actor AS source,
+  l.intent AS intent,
+  l.group_id AS group_id,
+  l.op AS op,
+  l.entity AS kind,
+  l.payload AS payload,
+  l.created_at AS created_at
+`;
+var LOG_FROM_JOIN = "FROM ops l";
+function workstreamScopeSql(column = "l.key") {
+  return `(${column} = ? OR ${column} LIKE ? ESCAPE '\\')`;
 }
-function sleep(ms) {
-  return currentSleep(ms);
+function workstreamScopeParams(workstream) {
+  const escaped = workstream.replace(/[\\%_]/g, (c) => `\\${c}`);
+  return [workstream, `${escaped}/%`];
 }
-async function listSessions() {
-  try {
-    const out = await tmux(["list-sessions", "-F", "#{session_name}"]);
-    return out.split("\n").filter((line) => line.length > 0).map((name) => ({ name }));
-  } catch (err) {
-    if (err instanceof TmuxError && /no server running|no sessions/i.test(err.stderr)) {
-      return [];
-    }
-    throw err;
+var TOUCH_OP_FILTER = `NOT (
+  l.intent IS NOT NULL
+  AND l.op = 'put'
+  AND l.payload LIKE '{"updated_at":%'
+  AND LENGTH(l.payload) < 45
+)`;
+var MACHINE_WIDE_KEY = "";
+var GroupIdAmbiguousError = class extends Error {
+  constructor(prefix, candidates) {
+    super(
+      `group id ${JSON.stringify(prefix)} is ambiguous: matches ${candidates.length} groups (${candidates.slice(0, 4).map((c) => c.slice(0, 12)).join(", ")}${candidates.length > 4 ? ", \u2026" : ""})`
+    );
+    this.prefix = prefix;
+    this.candidates = candidates;
+    this.name = "GroupIdAmbiguousError";
+  }
+  prefix;
+  candidates;
+  errorNextSteps() {
+    return [
+      { intent: "List recent groups with their ids", command: "mu undo" },
+      {
+        intent: "Retry with more characters",
+        command: `mu log --group ${this.candidates[0] ?? "<full-id>"}`
+      }
+    ];
   }
+};
+function groupIdFromPrefix(db, prefix) {
+  if (prefix === "") return null;
+  const rows = db.prepare(
+    `SELECT DISTINCT group_id AS groupId FROM ops
+        WHERE group_id = @exact OR group_id LIKE @prefix || '%' ESCAPE '\\'`
+  ).all({ exact: prefix, prefix: prefix.replace(/[\\%_]/g, (c) => `\\${c}`) });
+  const exact = rows.find((r) => r.groupId === prefix);
+  if (exact !== void 0) return exact.groupId;
+  const first = rows[0];
+  if (rows.length === 1 && first !== void 0) return first.groupId;
+  if (rows.length === 0) return null;
+  throw new GroupIdAmbiguousError(
+    prefix,
+    rows.map((r) => r.groupId)
+  );
 }
-async function sessionExists(name) {
-  const result = await currentExecutor(["has-session", "-t", name]);
-  return result.exitCode === 0;
+function machineId(db) {
+  const row = db.prepare("SELECT machine_id FROM machine_identity WHERE id = 1").get();
+  return row?.machine_id ?? "unknown";
 }
-async function newSession(name, opts = {}) {
-  const args = ["new-session"];
-  if (opts.detached !== false) args.push("-d");
-  args.push("-s", name);
-  if (opts.windowName) args.push("-n", opts.windowName);
-  if (opts.cwd) args.push("-c", opts.cwd);
-  appendEnvFlags(args, opts.env);
-  if (opts.command) args.push(opts.command);
-  await tmux(args);
+function rowFromDb(row) {
+  return {
+    seq: row.seq,
+    workstreamName: row.workstream === MACHINE_WIDE_KEY ? null : row.workstream,
+    source: row.source ?? "system",
+    intent: row.intent,
+    group: row.group_id,
+    op: row.op,
+    kind: row.kind,
+    payload: row.payload,
+    createdAt: row.created_at
+  };
 }
-async function newSessionWithPane(name, opts) {
-  const args = ["new-session"];
-  if (opts.detached !== false) args.push("-d");
-  args.push("-s", name, "-n", opts.windowName);
-  if (opts.cwd) args.push("-c", opts.cwd);
-  appendEnvFlags(args, opts.env);
-  args.push("-P", "-F", "#{pane_id}", opts.command);
-  const out = (await tmux(args)).trim();
-  assertValidPaneId(out);
-  return out;
+function appendLog(db, opts) {
+  const kind = opts.kind ?? "message";
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const key = opts.workstream ?? MACHINE_WIDE_KEY;
+  const group = randomUUID2();
+  const result = db.prepare(
+    `INSERT INTO ops (hlc, machine_id, group_id, actor, intent, entity, key, op, payload, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 'put', ?, ?)`
+  ).run(
+    nextHlc(db),
+    machineId(db),
+    group,
+    opts.source,
+    opts.intent ?? null,
+    kind,
+    key,
+    opts.payload,
+    createdAt
+  );
+  return {
+    seq: Number(result.lastInsertRowid),
+    workstreamName: opts.workstream,
+    source: opts.source,
+    intent: opts.intent ?? null,
+    group,
+    op: "put",
+    kind,
+    payload: opts.payload,
+    createdAt
+  };
 }
-async function killSession(name) {
-  const result = await currentExecutor(["kill-session", "-t", name]);
-  if (result.exitCode !== 0 && !/can't find session|session not found|no server running|no current target/i.test(result.stderr)) {
-    throw new TmuxError(
-      ["kill-session", "-t", name],
-      result.stderr,
-      result.stdout,
-      result.exitCode
-    );
+function listLogs(db, opts = {}) {
+  const conditions = [];
+  const params = [];
+  if (opts.workstream === null) {
+    conditions.push("l.key = ?");
+    params.push(MACHINE_WIDE_KEY);
+  } else if (opts.workstream !== void 0) {
+    conditions.push(workstreamScopeSql());
+    params.push(...workstreamScopeParams(opts.workstream));
   }
-}
-async function listWindows(session) {
-  if (session) {
-    const out2 = await tmux(["list-windows", "-t", session, "-F", "#{window_id}	#{window_name}"]);
-    return parseWindows(out2);
+  if (opts.since !== void 0) {
+    conditions.push("l.seq > ?");
+    params.push(opts.since);
   }
-  const out = await tmux([
-    "list-windows",
-    "-a",
-    "-F",
-    "#{session_name}	#{window_id}	#{window_name}"
-  ]);
-  const windows = [];
-  for (const line of out.split("\n")) {
-    if (line.length === 0) continue;
-    const [sessionName, id, name] = line.split("	");
-    if (!sessionName || !id || name === void 0) continue;
-    windows.push({ id, name, sessionName });
+  if (opts.source !== void 0) {
+    conditions.push("l.actor = ?");
+    params.push(opts.source);
   }
-  return windows;
-}
-function parseWindows(output) {
-  const windows = [];
-  for (const line of output.split("\n")) {
-    if (line.length === 0) continue;
-    const [id, name] = line.split("	");
-    if (!id || name === void 0) continue;
-    windows.push({ id, name });
+  if (opts.kind !== void 0) {
+    conditions.push("l.entity = ?");
+    params.push(opts.kind);
   }
-  return windows;
+  if (opts.intent !== void 0) {
+    const spellings = intentSpellings(opts.intent);
+    conditions.push(`l.intent IN (${spellings.map(() => "?").join(", ")})`);
+    params.push(...spellings);
+  }
+  if (opts.group !== void 0) {
+    conditions.push("l.group_id = ?");
+    params.push(opts.group);
+  }
+  conditions.push(TOUCH_OP_FILTER);
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  if (opts.limit !== void 0 && opts.since === void 0) {
+    const rowsDesc = db.prepare(`SELECT ${SELECT_LOG_COLS} ${LOG_FROM_JOIN} ${where} ORDER BY l.seq DESC LIMIT ?`).all(...params, opts.limit);
+    return rowsDesc.reverse().map(rowFromDb);
+  }
+  let sql = `SELECT ${SELECT_LOG_COLS} ${LOG_FROM_JOIN} ${where} ORDER BY l.seq ASC`;
+  if (opts.limit !== void 0) {
+    sql += " LIMIT ?";
+    params.push(opts.limit);
+  }
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(rowFromDb);
 }
-async function newWindow(opts) {
-  const args = ["new-window"];
-  if (opts.detached !== false) args.push("-d");
-  if (opts.session) args.push("-t", opts.session);
-  args.push("-n", opts.name);
-  if (opts.cwd) args.push("-c", opts.cwd);
-  appendEnvFlags(args, opts.env);
-  args.push("-P", "-F", "#{pane_id}", opts.command);
-  const out = (await tmux(args)).trim();
-  assertValidPaneId(out);
-  return out;
+function latestSeq(db, workstream) {
+  const row = workstream === void 0 ? db.prepare(`SELECT MAX(seq) AS s FROM ops l WHERE ${TOUCH_OP_FILTER}`).get() : db.prepare(
+    `SELECT MAX(seq) AS s FROM ops l WHERE ${workstreamScopeSql()} AND ${TOUCH_OP_FILTER}`
+  ).get(...workstreamScopeParams(workstream));
+  return row.s ?? 0;
 }
-async function listPanesInSession(session) {
-  const args = [
-    "list-panes",
+function emitEvent(db, workstream, intent, payload, source = "system") {
+  appendLog(db, { workstream, source, kind: entityForIntent(intent), payload, intent });
+}
+function entityForIntent(intent) {
+  const dot = intent.indexOf(".");
+  return dot === -1 ? intent : intent.slice(0, dot);
+}
+function lastClaimOp(db, workstream, localId) {
+  const row = db.prepare(
+    `SELECT actor, created_at FROM ops
+        WHERE key = ? AND intent = 'task.claim'
+        ORDER BY seq DESC LIMIT 1`
+  ).get(`${workstream}/${localId}`);
+  return row ?? null;
+}
+function lastClaimEventAt(db, workstream, localId) {
+  return lastClaimOp(db, workstream, localId)?.created_at ?? null;
+}
+
+// src/mux.ts
+var mux_exports = {};
+__export(mux_exports, {
+  HerdrCommandOverrideError: () => HerdrCommandOverrideError,
+  HerdrError: () => HerdrError,
+  HerdrNotImplementedError: () => HerdrNotImplementedError,
+  HerdrSyntaxError: () => HerdrSyntaxError,
+  HerdrUnsupportedCliError: () => HerdrUnsupportedCliError,
+  HerdrWorkspaceGroupCloseError: () => HerdrWorkspaceGroupCloseError,
+  MuxError: () => MuxError,
+  NoMultiplexerError: () => NoMultiplexerError,
+  PaneNotFoundError: () => PaneNotFoundError,
+  activeMux: () => activeMux,
+  detectMux: () => detectMux,
+  herdrBackend: () => herdrBackend,
+  isHerdrStatusUsable: () => isHerdrStatusUsable,
+  muxByName: () => muxByName,
+  parseAgentNameFromTitle: () => parseAgentNameFromTitle,
+  resetHerdrExecutor: () => resetHerdrExecutor,
+  resetMux: () => resetMux,
+  setHerdrExecutor: () => setHerdrExecutor,
+  setMuxForTests: () => setMuxForTests,
+  tmuxBackend: () => tmuxBackend
+});
+
+// src/mux/herdr.ts
+import { execa as execa2 } from "execa";
+
+// src/mux/tmux.ts
+import { execa } from "execa";
+
+// src/mux/input-timing.ts
+var TAIL_WINDOW_LINES = 100;
+var TAIL_LINES = 20;
+var BUSY_MARKERS = ["to interrupt)"];
+var BRAILLE_SPINNER_RE = /[\u2800-\u28ff]/;
+function extractTail(scrollback) {
+  const lines = scrollback.split("\n");
+  const window = lines.slice(-TAIL_WINDOW_LINES);
+  let end = window.length;
+  while (end > 0 && (window[end - 1] ?? "").trim() === "") end--;
+  return window.slice(Math.max(0, end - TAIL_LINES), end).join("\n");
+}
+function paneLooksBusy(scrollback) {
+  const tail = extractTail(scrollback);
+  return BUSY_MARKERS.some((marker) => tail.includes(marker)) || BRAILLE_SPINNER_RE.test(tail);
+}
+
+// src/mux/types.ts
+function parseAgentNameFromTitle(title) {
+  const idx = title.indexOf(" \xB7 ");
+  return idx === -1 ? title.trim() : title.slice(0, idx).trim();
+}
+var MuxError = class extends Error {
+  name = "MuxError";
+  errorNextSteps() {
+    return [{ intent: "Run health check", command: "mu doctor" }];
+  }
+};
+var PaneNotFoundError = class extends Error {
+  constructor(paneId, backend) {
+    super(`${backend?.name ?? "mux"} pane not found: ${paneId}`);
+    this.paneId = paneId;
+    this.backend = backend;
+  }
+  paneId;
+  backend;
+  name = "PaneNotFoundError";
+  errorNextSteps() {
+    return [
+      ...this.backend?.paneNotFoundNextSteps(this.paneId) ?? [],
+      {
+        intent: "List workstreams to choose the right scope",
+        command: "mu workstream list"
+      },
+      {
+        intent: "List registered agents and orphan panes in that scope",
+        command: "mu agent list -w <workstream>"
+      }
+    ];
+  }
+};
+var NoMultiplexerError = class extends Error {
+  constructor(tried) {
+    super(
+      `no supported multiplexer found (tried: ${tried.join(", ")}). mu drives agents through tmux panes.`
+    );
+    this.tried = tried;
+  }
+  tried;
+  name = "NoMultiplexerError";
+  errorNextSteps() {
+    return [
+      { intent: "Run health check", command: "mu doctor" },
+      { intent: "Verify tmux is installed", command: "tmux -V" },
+      { intent: "Force a specific backend", command: "MU_MUX=tmux mu <verb>" }
+    ];
+  }
+};
+
+// src/mux/tmux.ts
+var TmuxError = class extends MuxError {
+  constructor(args, stderr, stdout, exitCode) {
+    const detail = stderr.trim() || stdout.trim() || "no output";
+    super(`tmux ${args.join(" ")} failed (exit ${exitCode}): ${detail}`);
+    this.args = args;
+    this.stderr = stderr;
+    this.stdout = stdout;
+    this.exitCode = exitCode;
+    this.name = "TmuxError";
+  }
+  args;
+  stderr;
+  stdout;
+  exitCode;
+  errorNextSteps() {
+    return [
+      { intent: "Run health check", command: "mu doctor" },
+      {
+        intent: "Verify tmux is running and reachable",
+        command: "tmux info | head"
+      },
+      {
+        intent: "Check the failing tmux command in isolation",
+        command: `tmux ${this.args.join(" ")}`
+      }
+    ];
+  }
+};
+var PANE_ID_RE = /^%\d+$/;
+function isValidPaneId(s) {
+  return PANE_ID_RE.test(s);
+}
+function assertValidPaneId(s) {
+  if (!isValidPaneId(s)) {
+    throw new TypeError(`invalid tmux pane id: ${JSON.stringify(s)} (expected /^%\\d+$/)`);
+  }
+}
+function defaultSendDelayMs() {
+  const raw = process.env.MU_SEND_DELAY_MS;
+  if (raw === void 0) return 500;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed < 0) return 500;
+  return parsed;
+}
+function tmuxGlobalFlags() {
+  const socket = process.env.MU_TMUX_SOCKET;
+  if (socket === void 0 || socket.length === 0) return [];
+  return ["-L", socket, "-f", "/dev/null"];
+}
+var realExecutor = async (args) => {
+  const result = await execa("tmux", [...tmuxGlobalFlags(), ...args], { reject: false });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    exitCode: result.exitCode ?? null
+  };
+};
+var currentExecutor = realExecutor;
+function setTmuxExecutor(executor) {
+  const previous = currentExecutor;
+  currentExecutor = executor;
+  return previous;
+}
+function resetTmuxExecutor() {
+  currentExecutor = realExecutor;
+}
+async function tmux(args) {
+  const result = await currentExecutor(args);
+  if (result.exitCode !== 0) {
+    throw new TmuxError([...args], result.stderr, result.stdout, result.exitCode);
+  }
+  return result.stdout;
+}
+var currentSleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+function setSleepForTests(impl) {
+  const previous = currentSleep;
+  currentSleep = impl;
+  return previous;
+}
+function resetSleep() {
+  currentSleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+}
+function sleep(ms) {
+  return currentSleep(ms);
+}
+async function listSessions() {
+  try {
+    const out = await tmux(["list-sessions", "-F", "#{session_name}"]);
+    return out.split("\n").filter((line) => line.length > 0).map((name) => ({ name }));
+  } catch (err) {
+    if (err instanceof TmuxError && /no server running|no sessions/i.test(err.stderr)) {
+      return [];
+    }
+    throw err;
+  }
+}
+async function sessionExists(name) {
+  const result = await currentExecutor(["has-session", "-t", name]);
+  return result.exitCode === 0;
+}
+async function newSession(name, opts = {}) {
+  const args = ["new-session"];
+  if (opts.detached !== false) args.push("-d");
+  args.push("-s", name);
+  if (opts.windowName) args.push("-n", opts.windowName);
+  if (opts.cwd) args.push("-c", opts.cwd);
+  appendEnvFlags(args, opts.env);
+  if (opts.command) args.push(opts.command);
+  await tmux(args);
+}
+async function newSessionWithPane(name, opts) {
+  const args = ["new-session"];
+  if (opts.detached !== false) args.push("-d");
+  args.push("-s", name, "-n", opts.windowName);
+  if (opts.cwd) args.push("-c", opts.cwd);
+  appendEnvFlags(args, opts.env);
+  args.push("-P", "-F", "#{pane_id}", opts.command);
+  const out = (await tmux(args)).trim();
+  assertValidPaneId(out);
+  return out;
+}
+async function killSession(name) {
+  const result = await currentExecutor(["kill-session", "-t", name]);
+  if (result.exitCode !== 0 && !/can't find session|session not found|no server running|no current target/i.test(result.stderr)) {
+    throw new TmuxError(
+      ["kill-session", "-t", name],
+      result.stderr,
+      result.stdout,
+      result.exitCode
+    );
+  }
+}
+async function listWindows(session) {
+  if (session) {
+    const out2 = await tmux(["list-windows", "-t", session, "-F", "#{window_id}	#{window_name}"]);
+    return parseWindows(out2);
+  }
+  const out = await tmux([
+    "list-windows",
+    "-a",
+    "-F",
+    "#{session_name}	#{window_id}	#{window_name}"
+  ]);
+  const windows = [];
+  for (const line of out.split("\n")) {
+    if (line.length === 0) continue;
+    const [sessionName, id, name] = line.split("	");
+    if (!sessionName || !id || name === void 0) continue;
+    windows.push({ id, name, sessionName });
+  }
+  return windows;
+}
+function parseWindows(output) {
+  const windows = [];
+  for (const line of output.split("\n")) {
+    if (line.length === 0) continue;
+    const [id, name] = line.split("	");
+    if (!id || name === void 0) continue;
+    windows.push({ id, name });
+  }
+  return windows;
+}
+async function newWindow(opts) {
+  const args = ["new-window"];
+  if (opts.detached !== false) args.push("-d");
+  if (opts.session) args.push("-t", opts.session);
+  args.push("-n", opts.name);
+  if (opts.cwd) args.push("-c", opts.cwd);
+  appendEnvFlags(args, opts.env);
+  args.push("-P", "-F", "#{pane_id}", opts.command);
+  const out = (await tmux(args)).trim();
+  assertValidPaneId(out);
+  return out;
+}
+async function listPanesInSession(session) {
+  const args = [
+    "list-panes",
     "-s",
     "-t",
     session,
@@ -1655,970 +1969,663 @@ var TAB_ID_RE = new RegExp(`^w${HERDR_ORDINAL}:t${HERDR_ORDINAL}$`);
 function isValidPaneId2(s) {
   return PANE_ID_RE2.test(s);
 }
-function assertValidPaneId2(s) {
-  if (!isValidPaneId2(s)) {
-    throw new TypeError(
-      `invalid herdr pane id: ${JSON.stringify(s)} (expected ${PANE_ID_RE2.source})`
-    );
-  }
-}
-function herdrGlobalFlags() {
-  const session = process.env.MU_HERDR_SESSION;
-  if (session === void 0 || session.length === 0) return [];
-  return ["--session", session];
-}
-var realExecutor2 = async (args) => {
-  const result = await execa2("herdr", [...herdrGlobalFlags(), ...args], { reject: false });
-  return {
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-    exitCode: result.exitCode ?? null
-  };
-};
-var currentExecutor2 = realExecutor2;
-function setHerdrExecutor(executor) {
-  const previous = currentExecutor2;
-  currentExecutor2 = executor;
-  return previous;
-}
-function resetHerdrExecutor() {
-  currentExecutor2 = realExecutor2;
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function asString(v) {
-  return typeof v === "string" ? v : void 0;
-}
-function parseErrorEnvelope(stderr) {
-  const trimmed = stderr.trim();
-  if (trimmed.length === 0) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return void 0;
-  }
-  if (!isRecord(parsed)) return void 0;
-  const err = parsed.error;
-  if (!isRecord(err)) return void 0;
-  const code = asString(err.code);
-  const message = asString(err.message);
-  if (code === void 0) return void 0;
-  return { code, message: message ?? code };
-}
-async function herdr(args) {
-  const result = await currentExecutor2(args);
-  if (result.exitCode === 2) {
-    throw new HerdrSyntaxError([...args], result.stderr || result.stdout);
-  }
-  if (result.exitCode !== 0) {
-    throw new HerdrError(
-      [...args],
-      result.stderr,
-      result.stdout,
-      result.exitCode,
-      parseErrorEnvelope(result.stderr)?.code
-    );
-  }
-  const trimmed = result.stdout.trim();
-  if (trimmed.length === 0) return {};
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    throw new HerdrError([...args], result.stderr, result.stdout, result.exitCode);
-  }
-  if (!isRecord(parsed)) return {};
-  const inner = parsed.result;
-  return isRecord(inner) ? inner : {};
-}
-async function herdrTolerating(args, tolerate) {
-  try {
-    return await herdr(args);
-  } catch (err) {
-    if (err instanceof HerdrError && err.code !== void 0 && tolerate.includes(err.code)) {
-      return void 0;
-    }
-    throw err;
-  }
-}
-function readWorkspace(v) {
-  if (!isRecord(v)) return void 0;
-  const workspaceId = asString(v.workspace_id);
-  if (workspaceId === void 0) return void 0;
-  return { workspaceId, label: asString(v.label) ?? "" };
-}
-function readTab(v) {
-  if (!isRecord(v)) return void 0;
-  const id = asString(v.tab_id);
-  if (id === void 0) return void 0;
-  return { id, name: asString(v.label) ?? "" };
-}
-function readPane(v) {
-  if (!isRecord(v)) return void 0;
-  const paneId = asString(v.pane_id);
-  if (paneId === void 0) return void 0;
-  return {
-    paneId,
-    // herdr's optional `label` is what `pane rename` writes and is
-    // therefore mu's pane-title equivalent.
-    title: asString(v.label) ?? "",
-    // herdr does not report a foreground command on `pane list`; the
-    // authoritative answer costs a `pane process-info` round trip per
-    // pane. Callers that need it use `paneCommand()`.
-    command: "",
-    windowId: asString(v.tab_id)
-  };
-}
-function readArray(result, key) {
-  const v = result[key];
-  return Array.isArray(v) ? v : [];
-}
-async function listWorkspaces() {
-  const result = await herdr(["workspace", "list"]);
-  const out = [];
-  for (const raw of readArray(result, "workspaces")) {
-    const ws = readWorkspace(raw);
-    if (ws) out.push(ws);
-  }
-  return out;
-}
-async function listSessions2() {
-  return (await listWorkspaces()).map((ws) => ({ name: ws.label }));
-}
-async function resolveWorkspaceId(name) {
-  for (const ws of await listWorkspaces()) {
-    if (ws.label === name) return ws.workspaceId;
-  }
-  return void 0;
-}
-async function requireWorkspaceId(name) {
-  const id = await resolveWorkspaceId(name);
-  if (id === void 0) {
-    throw new HerdrError(
-      ["workspace", "list"],
-      `{"error":{"code":"workspace_not_found","message":"no herdr workspace labelled ${name}"}}`,
-      "",
-      1,
-      "workspace_not_found"
-    );
-  }
-  return id;
-}
-async function sessionExists2(name) {
-  return await resolveWorkspaceId(name) !== void 0;
-}
-async function newSession2(name, opts = {}) {
-  rejectCommand("newSession", opts.command);
-  const args = ["workspace", "create", "--label", name, "--no-focus"];
-  if (opts.cwd) args.push("--cwd", opts.cwd);
-  appendEnvFlags2(args, opts.env);
-  await herdr(args);
-}
-async function newSessionWithPane2(name, opts) {
-  rejectCommand("newSessionWithPane", opts.command);
-  const args = ["workspace", "create", "--label", name, "--no-focus"];
-  if (opts.cwd) args.push("--cwd", opts.cwd);
-  appendEnvFlags2(args, opts.env);
-  const result = await herdr(args);
-  return readCreatedPaneId(result, "root_pane", args);
-}
-async function killSession2(name) {
-  const id = await resolveWorkspaceId(name);
-  if (id === void 0) return;
-  try {
-    await herdrTolerating(["workspace", "close", id], ["workspace_not_found"]);
-  } catch (err) {
-    if (err instanceof HerdrError && err.code === GROUP_CLOSE_REQUIRED_CODE) {
-      throw new HerdrWorkspaceGroupCloseError(name, id, err.message);
-    }
-    throw err;
-  }
-}
-async function listWindows2(session) {
-  if (session !== void 0) {
-    const id = await resolveWorkspaceId(session);
-    if (id === void 0) return [];
-    return readTabs(await herdr(["tab", "list", "--workspace", id]));
-  }
-  const windows = [];
-  for (const ws of await listWorkspaces()) {
-    for (const tab of readTabs(await herdr(["tab", "list", "--workspace", ws.workspaceId]))) {
-      windows.push({ ...tab, sessionName: ws.label });
-    }
-  }
-  return windows;
-}
-function readTabs(result) {
-  const out = [];
-  for (const raw of readArray(result, "tabs")) {
-    const tab = readTab(raw);
-    if (tab) out.push(tab);
-  }
-  return out;
-}
-async function newWindow2(opts) {
-  rejectCommand("newWindow", opts.command);
-  const args = ["tab", "create"];
-  if (opts.session !== void 0) {
-    args.push("--workspace", await requireWorkspaceId(opts.session));
-  }
-  args.push("--label", opts.name, "--no-focus");
-  if (opts.cwd) args.push("--cwd", opts.cwd);
-  appendEnvFlags2(args, opts.env);
-  return readCreatedPaneId(await herdr(args), "root_pane", args);
-}
-async function selectLayout2(_window, _layout) {
-}
-async function listPanesInSession2(session) {
-  const id = await resolveWorkspaceId(session);
-  if (id === void 0) return [];
-  const result = await herdrTolerating(
-    ["pane", "list", "--workspace", id],
-    ["workspace_not_found"]
-  );
-  if (result === void 0) return [];
-  return readPanes(result).map((p) => ({ ...p, sessionName: session }));
-}
-async function listPanes2(target) {
-  if (target !== void 0 && target !== "*") {
-    if (TAB_ID_RE.test(target)) {
-      const workspaceId = target.split(":")[0] ?? target;
-      const panes2 = readPanes(await herdr(["pane", "list", "--workspace", workspaceId]));
-      return panes2.filter((p) => p.windowId === target);
-    }
-    if (WORKSPACE_ID_RE.test(target)) {
-      return readPanes(await herdr(["pane", "list", "--workspace", target]));
-    }
-    return listPanesInSession2(target);
-  }
-  const ambient = process.env.HERDR_WORKSPACE_ID;
-  if (target === void 0 && ambient !== void 0 && WORKSPACE_ID_RE.test(ambient)) {
-    return readPanes(await herdr(["pane", "list", "--workspace", ambient]));
-  }
-  const panes = [];
-  for (const ws of await listWorkspaces()) {
-    for (const pane of readPanes(await herdr(["pane", "list", "--workspace", ws.workspaceId]))) {
-      panes.push({ ...pane, sessionName: ws.label });
-    }
-  }
-  return panes;
-}
-function readPanes(result) {
-  const out = [];
-  for (const raw of readArray(result, "panes")) {
-    const pane = readPane(raw);
-    if (pane) out.push(pane);
+function assertValidPaneId2(s) {
+  if (!isValidPaneId2(s)) {
+    throw new TypeError(
+      `invalid herdr pane id: ${JSON.stringify(s)} (expected ${PANE_ID_RE2.source})`
+    );
   }
-  return out;
 }
-async function splitWindow2(opts) {
-  rejectCommand("splitWindow", opts.command);
-  assertValidPaneId2(opts.target);
-  const args = [
-    "pane",
-    "split",
-    opts.target,
-    "--direction",
-    opts.horizontal === false ? "down" : "right",
-    "--no-focus"
-  ];
-  if (opts.cwd) args.push("--cwd", opts.cwd);
-  appendEnvFlags2(args, opts.env);
-  return readCreatedPaneId(await herdr(args), "pane", args);
+function herdrGlobalFlags() {
+  const session = process.env.MU_HERDR_SESSION;
+  if (session === void 0 || session.length === 0) return [];
+  return ["--session", session];
 }
-async function killPane2(paneId) {
-  assertValidPaneId2(paneId);
-  await herdrTolerating(["pane", "close", paneId], ["pane_not_found", "workspace_not_found"]);
+var realExecutor2 = async (args) => {
+  const result = await execa2("herdr", [...herdrGlobalFlags(), ...args], { reject: false });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    exitCode: result.exitCode ?? null
+  };
+};
+var currentExecutor2 = realExecutor2;
+function setHerdrExecutor(executor) {
+  const previous = currentExecutor2;
+  currentExecutor2 = executor;
+  return previous;
 }
-async function paneExists2(paneId) {
-  if (!isValidPaneId2(paneId)) return false;
-  const pane = await getPane(paneId);
-  return pane !== void 0;
+function resetHerdrExecutor() {
+  currentExecutor2 = realExecutor2;
 }
-async function getPane(paneId) {
-  const result = await herdrTolerating(
-    ["pane", "get", paneId],
-    ["pane_not_found", "workspace_not_found"]
-  );
-  if (result === void 0) return void 0;
-  return readPane(result.pane);
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-async function paneTTY2(paneId) {
-  assertValidPaneId2(paneId);
-  const result = await herdrTolerating(
-    ["pane", "process-info", "--pane", paneId],
-    ["pane_not_found", "workspace_not_found"]
-  );
-  if (result === void 0) throw new PaneNotFoundError(paneId);
-  const info = result.process_info;
-  const pid = isRecord(info) ? info.shell_pid : void 0;
-  if (typeof pid !== "number") throw new PaneNotFoundError(paneId);
-  const { readlink } = await import("fs/promises");
+function asString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function parseErrorEnvelope(stderr) {
+  const trimmed = stderr.trim();
+  if (trimmed.length === 0) return void 0;
+  let parsed;
   try {
-    return await readlink(`/proc/${pid}/fd/0`);
-  } catch (err) {
-    throw new HerdrError(
-      ["pane", "process-info", "--pane", paneId],
-      `cannot resolve the TTY for herdr pane ${paneId} (shell pid ${pid}) via /proc: ${String(err)}`,
-      "",
-      1
-    );
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
   }
+  if (!isRecord(parsed)) return void 0;
+  const err = parsed.error;
+  if (!isRecord(err)) return void 0;
+  const code = asString(err.code);
+  const message = asString(err.message);
+  if (code === void 0) return void 0;
+  return { code, message: message ?? code };
 }
-async function setPaneTitle2(paneId, title) {
-  assertValidPaneId2(paneId);
-  await herdr(["pane", "rename", paneId, title]);
-}
-async function getPaneTitle2(paneId) {
-  if (!isValidPaneId2(paneId)) return void 0;
-  const pane = await getPane(paneId).catch(() => void 0);
-  if (pane === void 0) return void 0;
-  return pane.title.length > 0 ? pane.title : void 0;
-}
-async function currentAgentName2() {
-  const paneId = process.env.HERDR_PANE_ID;
-  if (paneId === void 0 || !isValidPaneId2(paneId)) return void 0;
-  const title = await getPaneTitle2(paneId);
-  if (title === void 0) return void 0;
-  const idx = title.indexOf(" \xB7 ");
-  return idx === -1 ? title.trim() : title.slice(0, idx).trim();
-}
-async function currentSessionName2() {
-  const workspaceId = process.env.HERDR_WORKSPACE_ID;
-  if (workspaceId === void 0 || !WORKSPACE_ID_RE.test(workspaceId)) return void 0;
-  for (const ws of await listWorkspaces()) {
-    if (ws.workspaceId === workspaceId) return ws.label;
+async function herdr(args) {
+  const result = await currentExecutor2(args);
+  if (result.exitCode === 2) {
+    throw new HerdrSyntaxError([...args], result.stderr || result.stdout);
   }
-  return void 0;
-}
-var PANE_READY_RETRY_INTERVAL_MS = 50;
-var PANE_READY_MAX_ATTEMPTS = 60;
-async function startAgentInPane(opts) {
-  assertValidPaneId2(opts.paneId);
-  if (opts.commandSource !== "cli-key") {
-    throw new HerdrCommandOverrideError(
-      opts.cli,
-      opts.command,
-      // Name the env var only when that is actually where the override
-      // came from; "unset MU_PI_COMMAND" is useless advice to someone who
-      // typed --command.
-      opts.commandSource === "env" ? envVarNameForCli(opts.cli) : void 0
+  if (result.exitCode !== 0) {
+    throw new HerdrError(
+      [...args],
+      result.stderr,
+      result.stdout,
+      result.exitCode,
+      parseErrorEnvelope(result.stderr)?.code
     );
   }
-  const args = ["agent", "start", opts.name, "--kind", opts.cli, "--pane", opts.paneId];
-  for (let attempt = 1; ; attempt += 1) {
-    try {
-      await herdr(args);
-      return;
-    } catch (err) {
-      if (err instanceof HerdrSyntaxError) {
-        throw new HerdrUnsupportedCliError(opts.cli, err.output.trim().split("\n")[0] ?? "");
-      }
-      const busy = err instanceof HerdrError && err.code === "agent_pane_busy";
-      if (!busy || attempt >= PANE_READY_MAX_ATTEMPTS) throw err;
-      await sleep(PANE_READY_RETRY_INTERVAL_MS);
-    }
+  const trimmed = result.stdout.trim();
+  if (trimmed.length === 0) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new HerdrError([...args], result.stderr, result.stdout, result.exitCode);
   }
+  if (!isRecord(parsed)) return {};
+  const inner = parsed.result;
+  return isRecord(inner) ? inner : {};
 }
-function envVarNameForCli(cli) {
-  return `MU_${cli.toUpperCase().replace(/-/g, "_")}_COMMAND`;
-}
-var PROMPT_STALLED_CODE = "agent_prompt_stalled";
-var NO_AGENT_CODES = ["agent_not_found", "agent_not_recognized"];
-function defaultUndeliveredWarning2(warning) {
-  console.warn(`warning: ${warning.message}`);
-}
-async function sendToPane2(paneId, text, opts = {}) {
-  assertValidPaneId2(paneId);
-  const wait = opts.readinessMs === 0 ? [] : ["--wait"];
+async function herdrTolerating(args, tolerate) {
   try {
-    await herdr(["agent", "prompt", paneId, text, ...wait]);
-    return;
+    return await herdr(args);
   } catch (err) {
-    if (!(err instanceof HerdrError) || err.code === void 0) throw err;
-    if (err.code === PROMPT_STALLED_CODE) {
-      const warn2 = opts.onUndelivered ?? defaultUndeliveredWarning2;
-      warn2({
-        paneId,
-        reason: "paste-vanished",
-        message: `send to ${paneId} was submitted but the agent's state never changed (herdr: ${PROMPT_STALLED_CODE}). The agent may NOT have seen it. Read the pane, or re-send.`
-      });
-      return;
+    if (err instanceof HerdrError && err.code !== void 0 && tolerate.includes(err.code)) {
+      return void 0;
     }
-    if (!NO_AGENT_CODES.includes(err.code)) throw err;
+    throw err;
   }
-  await herdr(["pane", "run", paneId, text]);
 }
-async function capturePane2(paneId, opts = {}) {
-  assertValidPaneId2(paneId);
-  const args = ["pane", "read", paneId];
-  if (opts.lines === 0) {
-    args.push("--source", "visible");
-  } else {
-    args.push("--source", "recent-unwrapped");
-    if (opts.lines !== void 0) args.push("--lines", String(opts.lines));
+function readWorkspace(v) {
+  if (!isRecord(v)) return void 0;
+  const workspaceId = asString(v.workspace_id);
+  if (workspaceId === void 0) return void 0;
+  return { workspaceId, label: asString(v.label) ?? "" };
+}
+function readTab(v) {
+  if (!isRecord(v)) return void 0;
+  const id = asString(v.tab_id);
+  if (id === void 0) return void 0;
+  return { id, name: asString(v.label) ?? "" };
+}
+function readPane(v) {
+  if (!isRecord(v)) return void 0;
+  const paneId = asString(v.pane_id);
+  if (paneId === void 0) return void 0;
+  return {
+    paneId,
+    // herdr's optional `label` is what `pane rename` writes and is
+    // therefore mu's pane-title equivalent.
+    title: asString(v.label) ?? "",
+    // herdr does not report a foreground command on `pane list`; the
+    // authoritative answer costs a `pane process-info` round trip per
+    // pane. Callers that need it use `paneCommand()`.
+    command: "",
+    windowId: asString(v.tab_id)
+  };
+}
+function readArray(result, key) {
+  const v = result[key];
+  return Array.isArray(v) ? v : [];
+}
+async function listWorkspaces() {
+  const result = await herdr(["workspace", "list"]);
+  const out = [];
+  for (const raw of readArray(result, "workspaces")) {
+    const ws = readWorkspace(raw);
+    if (ws) out.push(ws);
   }
-  const result = await currentExecutor2(args);
-  if (result.exitCode === 2) throw new HerdrSyntaxError(args, result.stderr || result.stdout);
-  if (result.exitCode !== 0) {
-    throw new HerdrError(
-      args,
-      result.stderr,
-      result.stdout,
-      result.exitCode,
-      parseErrorEnvelope(result.stderr)?.code
-    );
+  return out;
+}
+async function listSessions2() {
+  return (await listWorkspaces()).map((ws) => ({ name: ws.label }));
+}
+async function resolveWorkspaceId(name) {
+  for (const ws of await listWorkspaces()) {
+    if (ws.label === name) return ws.workspaceId;
   }
-  return result.stdout;
+  return void 0;
 }
-function mapAgentStatus(agentStatus) {
-  switch (agentStatus) {
-    case "working":
-      return "busy";
-    case "blocked":
-      return "needs_permission";
-    default:
-      return "needs_input";
+async function requireWorkspaceId(name) {
+  const id = await resolveWorkspaceId(name);
+  if (id === void 0) {
+    throw new HerdrError(
+      ["workspace", "list"],
+      `{"error":{"code":"workspace_not_found","message":"no herdr workspace labelled ${name}"}}`,
+      "",
+      1,
+      "workspace_not_found"
+    );
   }
+  return id;
 }
-async function paneStatus(paneId) {
-  if (!isValidPaneId2(paneId)) return void 0;
-  const result = await herdrTolerating(
-    ["pane", "get", paneId],
-    ["pane_not_found", "workspace_not_found"]
-  );
-  if (result === void 0) return void 0;
-  const pane = result.pane;
-  const status = isRecord(pane) ? asString(pane.agent_status) : void 0;
-  if (status === void 0) return void 0;
-  return mapAgentStatus(status);
+async function sessionExists2(name) {
+  return await resolveWorkspaceId(name) !== void 0;
 }
-async function enableMuPaneBordersForSession2(_session) {
-  return 0;
+async function newSession2(name, opts = {}) {
+  rejectCommand("newSession", opts.command);
+  const args = ["workspace", "create", "--label", name, "--no-focus"];
+  if (opts.cwd) args.push("--cwd", opts.cwd);
+  appendEnvFlags2(args, opts.env);
+  await herdr(args);
 }
-async function enableMuPaneBordersForPane2(_paneId) {
+async function newSessionWithPane2(name, opts) {
+  rejectCommand("newSessionWithPane", opts.command);
+  const args = ["workspace", "create", "--label", name, "--no-focus"];
+  if (opts.cwd) args.push("--cwd", opts.cwd);
+  appendEnvFlags2(args, opts.env);
+  const result = await herdr(args);
+  return readCreatedPaneId(result, "root_pane", args);
 }
-function appendEnvFlags2(args, env) {
-  if (!env) return;
-  for (const [k, v] of Object.entries(env)) {
-    if (k.length === 0) throw new TypeError("herdr env key must be non-empty");
-    if (k.includes("=")) {
-      throw new TypeError(`herdr env key must not contain '=': ${JSON.stringify(k)}`);
+async function killSession2(name) {
+  const id = await resolveWorkspaceId(name);
+  if (id === void 0) return;
+  try {
+    await herdrTolerating(["workspace", "close", id], ["workspace_not_found"]);
+  } catch (err) {
+    if (err instanceof HerdrError && err.code === GROUP_CLOSE_REQUIRED_CODE) {
+      throw new HerdrWorkspaceGroupCloseError(name, id, err.message);
     }
-    args.push("--env", `${k}=${v}`);
+    throw err;
   }
 }
-function rejectCommand(method, command) {
-  if (command === void 0 || command.trim().length === 0) return;
-  throw new HerdrNotImplementedError(`${method} with a command`, "mux-herdr-spawn");
-}
-function readCreatedPaneId(result, key, args) {
-  const pane = readPane(result[key]);
-  if (pane === void 0) {
-    throw new HerdrError(
-      args,
-      `herdr response had no ${key}.pane_id: ${JSON.stringify(result)}`,
-      "",
-      0
-    );
+async function listWindows2(session) {
+  if (session !== void 0) {
+    const id = await resolveWorkspaceId(session);
+    if (id === void 0) return [];
+    return readTabs(await herdr(["tab", "list", "--workspace", id]));
   }
-  assertValidPaneId2(pane.paneId);
-  return pane.paneId;
-}
-function isHerdrStatusUsable(stdout) {
-  if (!/^\s*status:\s*running\s*$/m.test(stdout)) return false;
-  if (/^\s*endpoint_compatible:\s*no\s*$/m.test(stdout)) return false;
-  return !/^\s*compatible:\s*no\s*$/m.test(stdout);
+  const windows = [];
+  for (const ws of await listWorkspaces()) {
+    for (const tab of readTabs(await herdr(["tab", "list", "--workspace", ws.workspaceId]))) {
+      windows.push({ ...tab, sessionName: ws.label });
+    }
+  }
+  return windows;
 }
-async function herdrAvailable() {
-  const result = await currentExecutor2(["status"]).catch(() => void 0);
-  if (result === void 0 || result.exitCode !== 0) return false;
-  return isHerdrStatusUsable(result.stdout);
+function readTabs(result) {
+  const out = [];
+  for (const raw of readArray(result, "tabs")) {
+    const tab = readTab(raw);
+    if (tab) out.push(tab);
+  }
+  return out;
 }
-function attachHint2(target) {
-  if (target.window !== void 0) {
-    return `herdr session attach ${target.session} # then focus tab ${target.window}`;
+async function newWindow2(opts) {
+  rejectCommand("newWindow", opts.command);
+  const args = ["tab", "create"];
+  if (opts.session !== void 0) {
+    args.push("--workspace", await requireWorkspaceId(opts.session));
   }
-  return `herdr session attach ${target.session}`;
+  args.push("--label", opts.name, "--no-focus");
+  if (opts.cwd) args.push("--cwd", opts.cwd);
+  appendEnvFlags2(args, opts.env);
+  return readCreatedPaneId(await herdr(args), "root_pane", args);
 }
-function attachCommands2(target) {
-  return [{ command: "herdr", args: ["session", "attach", target.session] }];
+async function selectLayout2(_window, _layout) {
 }
-function paneNotFoundNextSteps2(paneId) {
-  return [
-    {
-      intent: `Verify the pane id ${paneId} actually exists`,
-      command: `herdr pane get ${paneId}`
-    },
-    {
-      intent: "List panes in the current workspace",
-      command: 'herdr pane list --workspace "$HERDR_WORKSPACE_ID"'
-    }
-  ];
+async function listPanesInSession2(session) {
+  const id = await resolveWorkspaceId(session);
+  if (id === void 0) return [];
+  const result = await herdrTolerating(
+    ["pane", "list", "--workspace", id],
+    ["workspace_not_found"]
+  );
+  if (result === void 0) return [];
+  return readPanes(result).map((p) => ({ ...p, sessionName: session }));
 }
-async function healthCheck2() {
-  let version = null;
-  try {
-    const result = await currentExecutor2(["status"]);
-    if (result.exitCode === 0) {
-      const match = /^\s*version:\s*(\S+)\s*$/m.exec(result.stdout);
-      version = match?.[1] ?? null;
+async function listPanes2(target) {
+  if (target !== void 0 && target !== "*") {
+    if (TAB_ID_RE.test(target)) {
+      const workspaceId = target.split(":")[0] ?? target;
+      const panes2 = readPanes(await herdr(["pane", "list", "--workspace", workspaceId]));
+      return panes2.filter((p) => p.windowId === target);
     }
-  } catch {
-    version = null;
+    if (WORKSPACE_ID_RE.test(target)) {
+      return readPanes(await herdr(["pane", "list", "--workspace", target]));
+    }
+    return listPanesInSession2(target);
   }
-  return {
-    name: "herdr",
-    ok: version !== null,
-    version,
-    env: [
-      { name: "$HERDR_ENV", value: process.env.HERDR_ENV ?? null },
-      { name: "$HERDR_WORKSPACE_ID", value: process.env.HERDR_WORKSPACE_ID ?? null },
-      { name: "$HERDR_PANE_ID", value: process.env.HERDR_PANE_ID ?? null }
-    ],
-    remediation: "start the herdr server (herdr status) or install herdr"
-  };
+  const ambient = process.env.HERDR_WORKSPACE_ID;
+  if (target === void 0 && ambient !== void 0 && WORKSPACE_ID_RE.test(ambient)) {
+    return readPanes(await herdr(["pane", "list", "--workspace", ambient]));
+  }
+  const panes = [];
+  for (const ws of await listWorkspaces()) {
+    for (const pane of readPanes(await herdr(["pane", "list", "--workspace", ws.workspaceId]))) {
+      panes.push({ ...pane, sessionName: ws.label });
+    }
+  }
+  return panes;
 }
-var herdrBackend = Object.freeze({
-  name: "herdr",
-  available: herdrAvailable,
-  isValidPaneId: isValidPaneId2,
-  assertValidPaneId: assertValidPaneId2,
-  listSessions: listSessions2,
-  sessionExists: sessionExists2,
-  newSession: newSession2,
-  newSessionWithPane: newSessionWithPane2,
-  killSession: killSession2,
-  listWindows: listWindows2,
-  newWindow: newWindow2,
-  selectLayout: selectLayout2,
-  listPanes: listPanes2,
-  listPanesInSession: listPanesInSession2,
-  splitWindow: splitWindow2,
-  killPane: killPane2,
-  paneExists: paneExists2,
-  paneTTY: paneTTY2,
-  setPaneTitle: setPaneTitle2,
-  getPaneTitle: getPaneTitle2,
-  currentAgentName: currentAgentName2,
-  currentSessionName: currentSessionName2,
-  startAgentInPane,
-  sendToPane: sendToPane2,
-  capturePane: capturePane2,
-  paneStatus,
-  enableMuPaneBordersForSession: enableMuPaneBordersForSession2,
-  enableMuPaneBordersForPane: enableMuPaneBordersForPane2,
-  attachHint: attachHint2,
-  attachCommands: attachCommands2,
-  paneNotFoundNextSteps: paneNotFoundNextSteps2,
-  healthCheck: healthCheck2
-});
-
-// src/mux/detect.ts
-var BACKENDS = [tmuxBackend, herdrBackend];
-function muxByName(name) {
-  for (const backend of BACKENDS) {
-    if (backend.name === name) return backend;
+function readPanes(result) {
+  const out = [];
+  for (const raw of readArray(result, "panes")) {
+    const pane = readPane(raw);
+    if (pane) out.push(pane);
   }
-  throw new Error(`unknown mux backend: ${name}`);
+  return out;
+}
+async function splitWindow2(opts) {
+  rejectCommand("splitWindow", opts.command);
+  assertValidPaneId2(opts.target);
+  const args = [
+    "pane",
+    "split",
+    opts.target,
+    "--direction",
+    opts.horizontal === false ? "down" : "right",
+    "--no-focus"
+  ];
+  if (opts.cwd) args.push("--cwd", opts.cwd);
+  appendEnvFlags2(args, opts.env);
+  return readCreatedPaneId(await herdr(args), "pane", args);
+}
+async function killPane2(paneId) {
+  assertValidPaneId2(paneId);
+  await herdrTolerating(["pane", "close", paneId], ["pane_not_found", "workspace_not_found"]);
 }
-var KNOWN_NAMES = BACKENDS.map((b) => b.name);
-async function detectMux() {
-  const override = process.env.MU_MUX;
-  if (override !== void 0 && override.length > 0) {
-    return muxByName(override);
-  }
-  if (process.env.HERDR_ENV === "1") return herdrBackend;
-  if (process.env.TMUX || process.env.TMUX_PANE) return tmuxBackend;
-  for (const backend of BACKENDS) {
-    if (await backend.available()) return backend;
-  }
-  throw new NoMultiplexerError(KNOWN_NAMES);
+async function paneExists2(paneId) {
+  if (!isValidPaneId2(paneId)) return false;
+  const pane = await getPane(paneId);
+  return pane !== void 0;
 }
-var cached;
-async function activeMux() {
-  if (cached === void 0) cached = await detectMux();
-  return cached;
+async function getPane(paneId) {
+  const result = await herdrTolerating(
+    ["pane", "get", paneId],
+    ["pane_not_found", "workspace_not_found"]
+  );
+  if (result === void 0) return void 0;
+  return readPane(result.pane);
 }
-function setMuxForTests(backend) {
-  const previous = cached;
-  cached = backend;
-  return previous;
+async function paneTTY2(paneId) {
+  assertValidPaneId2(paneId);
+  const result = await herdrTolerating(
+    ["pane", "process-info", "--pane", paneId],
+    ["pane_not_found", "workspace_not_found"]
+  );
+  if (result === void 0) throw new PaneNotFoundError(paneId);
+  const info = result.process_info;
+  const pid = isRecord(info) ? info.shell_pid : void 0;
+  if (typeof pid !== "number") throw new PaneNotFoundError(paneId);
+  const { readlink } = await import("fs/promises");
+  try {
+    return await readlink(`/proc/${pid}/fd/0`);
+  } catch (err) {
+    throw new HerdrError(
+      ["pane", "process-info", "--pane", paneId],
+      `cannot resolve the TTY for herdr pane ${paneId} (shell pid ${pid}) via /proc: ${String(err)}`,
+      "",
+      1
+    );
+  }
 }
-function resetMux() {
-  cached = void 0;
+async function setPaneTitle2(paneId, title) {
+  assertValidPaneId2(paneId);
+  await herdr(["pane", "rename", paneId, title]);
 }
-
-// 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 { 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";
-
-// src/glyphs.ts
-var AGENT_STATE_GLYPH = {
-  busy: "\uF04B",
-  // nf-fa-play
-  needs_input: "\uF186",
-  // nf-fa-moon_o
-  needs_permission: "\uF023",
-  // nf-fa-lock
-  unknown: "\uF059"
-  // nf-fa-question_circle
-};
-function agentStateGlyph(state) {
-  return AGENT_STATE_GLYPH[state] ?? GLYPH.unknown;
+async function getPaneTitle2(paneId) {
+  if (!isValidPaneId2(paneId)) return void 0;
+  const pane = await getPane(paneId).catch(() => void 0);
+  if (pane === void 0) return void 0;
+  return pane.title.length > 0 ? pane.title : void 0;
 }
-var GLYPH = {
-  /** Healthy, clean, passing, closed-successfully. */
-  ok: "\uF058",
-  // nf-fa-check_circle
-  /** Failed check. */
-  fail: "\uF057",
-  // nf-fa-times_circle
-  /** Needs attention but not broken (idle-but-assigned, stale warning). */
-  warn: "\uF071",
-  // nf-fa-warning
-  /** Workspace has uncommitted edits. */
-  dirty: "\uF005",
-  // nf-fa-star
-  /** Workspace is ≥ WORKSPACE_STALE_THRESHOLD commits behind main. */
-  stale: "\uF017",
-  // nf-fa-clock_o
-  /** Task is blocked by an incoming edge. */
-  blocked: "\uF0C1",
-  // nf-fa-link (chain)
-  /** Task is parked (OPEN/parked): open, but set aside on purpose. */
-  parked: "\uF04C",
-  // nf-fa-pause
-  /** Track whose roots merged (diamond dependency). */
-  merge: "\uF074",
-  // nf-fa-random
-  /** Agent owns more than one task (pane-title multi-count slot). */
-  multi: "\uF055",
-  // nf-fa-plus_circle
-  /** Filter toggle: enabled / disabled. */
-  on: "\uF111",
-  // nf-fa-circle
-  off: "\uF10C",
-  // nf-fa-circle_o
-  /** Status outside the known enum. */
-  unknown: "\uF059"
-  // nf-fa-question_circle
-};
-
-// src/logs.ts
-import { randomUUID as randomUUID2 } from "crypto";
-
-// src/hlc.ts
-var WALL_WIDTH = 15;
-var COUNTER_WIDTH = 6;
-var SEP = ".";
-var MAX_WALL = 10 ** WALL_WIDTH - 1;
-var MAX_COUNTER = 10 ** COUNTER_WIDTH - 1;
-var HlcParseError = class extends Error {
-  constructor(value) {
-    super(`Malformed HLC: ${JSON.stringify(value)}`);
-    this.value = value;
-    this.name = "HlcParseError";
+async function currentAgentName2() {
+  const paneId = process.env.HERDR_PANE_ID;
+  if (paneId === void 0 || !isValidPaneId2(paneId)) return void 0;
+  const title = await getPaneTitle2(paneId);
+  if (title === void 0) return void 0;
+  const idx = title.indexOf(" \xB7 ");
+  return idx === -1 ? title.trim() : title.slice(0, idx).trim();
+}
+async function currentSessionName2() {
+  const workspaceId = process.env.HERDR_WORKSPACE_ID;
+  if (workspaceId === void 0 || !WORKSPACE_ID_RE.test(workspaceId)) return void 0;
+  for (const ws of await listWorkspaces()) {
+    if (ws.workspaceId === workspaceId) return ws.label;
   }
-  value;
-};
-var HlcOverflowError = class extends Error {
-  constructor(field, value) {
-    super(
-      field === "counter" ? `HLC counter overflow (${value} > ${MAX_COUNTER}): more than ${MAX_COUNTER + 1} ops in one millisecond` : `HLC wall-clock overflow (${value} > ${MAX_WALL}): system clock is far in the future`
+  return void 0;
+}
+var PANE_READY_RETRY_INTERVAL_MS = 50;
+var PANE_READY_MAX_ATTEMPTS = 60;
+async function startAgentInPane(opts) {
+  assertValidPaneId2(opts.paneId);
+  if (opts.commandSource !== "cli-key") {
+    throw new HerdrCommandOverrideError(
+      opts.cli,
+      opts.command,
+      // Name the env var only when that is actually where the override
+      // came from; "unset MU_PI_COMMAND" is useless advice to someone who
+      // typed --command.
+      opts.commandSource === "env" ? envVarNameForCli(opts.cli) : void 0
     );
-    this.field = field;
-    this.value = value;
-    this.name = "HlcOverflowError";
   }
-  field;
-  value;
-};
-var MachineIdentityMissingError = class extends Error {
-  constructor() {
-    super("machine_identity row (id = 1) is missing; the DB was not opened via openDb()");
-    this.name = "MachineIdentityMissingError";
+  const args = ["agent", "start", opts.name, "--kind", opts.cli, "--pane", opts.paneId];
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      await herdr(args);
+      return;
+    } catch (err) {
+      if (err instanceof HerdrSyntaxError) {
+        throw new HerdrUnsupportedCliError(opts.cli, err.output.trim().split("\n")[0] ?? "");
+      }
+      const busy = err instanceof HerdrError && err.code === "agent_pane_busy";
+      if (!busy || attempt >= PANE_READY_MAX_ATTEMPTS) throw err;
+      await sleep(PANE_READY_RETRY_INTERVAL_MS);
+    }
   }
-};
-function formatHlc(hlc) {
-  const { wallMs, counter, machineId: machineId2 } = hlc;
-  if (!Number.isInteger(wallMs) || wallMs < 0) throw new HlcParseError(String(wallMs));
-  if (!Number.isInteger(counter) || counter < 0) throw new HlcParseError(String(counter));
-  if (wallMs > MAX_WALL) throw new HlcOverflowError("wall", wallMs);
-  if (counter > MAX_COUNTER) throw new HlcOverflowError("counter", counter);
-  if (machineId2.length === 0 || machineId2.includes(SEP)) throw new HlcParseError(machineId2);
-  return `${String(wallMs).padStart(WALL_WIDTH, "0")}${SEP}${String(counter).padStart(
-    COUNTER_WIDTH,
-    "0"
-  )}${SEP}${machineId2}`;
 }
-function parseHlc(value) {
-  const parts = value.split(SEP);
-  if (parts.length !== 3) throw new HlcParseError(value);
-  const [wall, counter, machineId2] = parts;
-  if (wall === void 0 || counter === void 0 || machineId2 === void 0) {
-    throw new HlcParseError(value);
+function envVarNameForCli(cli) {
+  return `MU_${cli.toUpperCase().replace(/-/g, "_")}_COMMAND`;
+}
+var PROMPT_STALLED_CODE = "agent_prompt_stalled";
+var NO_AGENT_CODES = ["agent_not_found", "agent_not_recognized"];
+function defaultUndeliveredWarning2(warning) {
+  console.warn(`warning: ${warning.message}`);
+}
+async function sendToPane2(paneId, text, opts = {}) {
+  assertValidPaneId2(paneId);
+  const wait = opts.readinessMs === 0 ? [] : ["--wait"];
+  try {
+    await herdr(["agent", "prompt", paneId, text, ...wait]);
+    return;
+  } catch (err) {
+    if (!(err instanceof HerdrError) || err.code === void 0) throw err;
+    if (err.code === PROMPT_STALLED_CODE) {
+      const warn2 = opts.onUndelivered ?? defaultUndeliveredWarning2;
+      warn2({
+        paneId,
+        reason: "paste-vanished",
+        message: `send to ${paneId} was submitted but the agent's state never changed (herdr: ${PROMPT_STALLED_CODE}). The agent may NOT have seen it. Read the pane, or re-send.`
+      });
+      return;
+    }
+    if (!NO_AGENT_CODES.includes(err.code)) throw err;
+  }
+  await herdr(["pane", "run", paneId, text]);
+}
+async function capturePane2(paneId, opts = {}) {
+  assertValidPaneId2(paneId);
+  const args = ["pane", "read", paneId];
+  if (opts.lines === 0) {
+    args.push("--source", "visible");
+  } else {
+    args.push("--source", "recent-unwrapped");
+    if (opts.lines !== void 0) args.push("--lines", String(opts.lines));
+  }
+  const result = await currentExecutor2(args);
+  if (result.exitCode === 2) throw new HerdrSyntaxError(args, result.stderr || result.stdout);
+  if (result.exitCode !== 0) {
+    throw new HerdrError(
+      args,
+      result.stderr,
+      result.stdout,
+      result.exitCode,
+      parseErrorEnvelope(result.stderr)?.code
+    );
   }
-  if (wall.length !== WALL_WIDTH || counter.length !== COUNTER_WIDTH || machineId2.length === 0) {
-    throw new HlcParseError(value);
+  return result.stdout;
+}
+function mapAgentStatus(agentStatus) {
+  switch (agentStatus) {
+    case "working":
+      return "busy";
+    case "blocked":
+      return "needs_permission";
+    default:
+      return "needs_input";
   }
-  if (!/^\d+$/.test(wall) || !/^\d+$/.test(counter)) throw new HlcParseError(value);
-  return { wallMs: Number(wall), counter: Number(counter), machineId: machineId2 };
 }
-function compareHlc(a, b) {
-  if (a < b) return -1;
-  if (a > b) return 1;
+async function paneStatus(paneId) {
+  if (!isValidPaneId2(paneId)) return void 0;
+  const result = await herdrTolerating(
+    ["pane", "get", paneId],
+    ["pane_not_found", "workspace_not_found"]
+  );
+  if (result === void 0) return void 0;
+  const pane = result.pane;
+  const status = isRecord(pane) ? asString(pane.agent_status) : void 0;
+  if (status === void 0) return void 0;
+  return mapAgentStatus(status);
+}
+async function enableMuPaneBordersForSession2(_session) {
   return 0;
 }
-function nextHlc(db, now = Date.now()) {
-  const row = db.prepare(
-    `UPDATE machine_identity
-          SET last_wall    = MAX(last_wall, @now),
-              last_counter = CASE WHEN @now > last_wall THEN 0 ELSE last_counter + 1 END
-        WHERE id = 1
-        RETURNING machine_id, last_wall, last_counter`
-  ).get({ now: Math.floor(now) });
-  if (!row) throw new MachineIdentityMissingError();
-  return formatHlc({ wallMs: row.last_wall, counter: row.last_counter, machineId: row.machine_id });
+async function enableMuPaneBordersForPane2(_paneId) {
 }
-function receiveHlc(db, remoteHlc, now = Date.now()) {
-  const remote = parseHlc(remoteHlc);
-  const wallNow = Math.floor(now);
-  const read = db.prepare(
-    "SELECT machine_id, last_wall, last_counter FROM machine_identity WHERE id = 1"
-  );
-  const write = db.prepare(
-    "UPDATE machine_identity SET last_wall = @wall, last_counter = @counter WHERE id = 1"
-  );
-  const advance = db.transaction(() => {
-    const row = read.get();
-    if (!row) throw new MachineIdentityMissingError();
-    const wall = Math.max(row.last_wall, remote.wallMs, wallNow);
-    const localAtMax = row.last_wall === wall;
-    const remoteAtMax = remote.wallMs === wall;
-    let counter;
-    if (!localAtMax && !remoteAtMax) {
-      counter = 0;
-    } else if (localAtMax && remoteAtMax) {
-      counter = Math.max(row.last_counter, remote.counter) + 1;
-    } else if (localAtMax) {
-      counter = row.last_counter + 1;
-    } else {
-      counter = remote.counter + 1;
+function appendEnvFlags2(args, env) {
+  if (!env) return;
+  for (const [k, v] of Object.entries(env)) {
+    if (k.length === 0) throw new TypeError("herdr env key must be non-empty");
+    if (k.includes("=")) {
+      throw new TypeError(`herdr env key must not contain '=': ${JSON.stringify(k)}`);
     }
-    if (counter > MAX_COUNTER) throw new HlcOverflowError("counter", counter);
-    write.run({ wall, counter });
-    return formatHlc({ wallMs: wall, counter, machineId: row.machine_id });
-  });
-  return advance.immediate();
+    args.push("--env", `${k}=${v}`);
+  }
 }
-
-// src/legacy-ops.ts
-var LEGACY_LOG_ONLY_INTENTS = /* @__PURE__ */ new Set(["workstream.export"]);
-function isLegacyLogOnlyIntent(intent) {
-  return intent !== null && LEGACY_LOG_ONLY_INTENTS.has(intent);
+function rejectCommand(method, command) {
+  if (command === void 0 || command.trim().length === 0) return;
+  throw new HerdrNotImplementedError(`${method} with a command`, "mux-herdr-spawn");
 }
-var LEGACY_INTENT_SYNONYMS = /* @__PURE__ */ new Map([
-  ["workstream.teardown", ["workstream.destroy"]]
-]);
-function intentSpellings(intent) {
-  const legacy = LEGACY_INTENT_SYNONYMS.get(intent);
-  return legacy === void 0 ? [intent] : [intent, ...legacy];
+function readCreatedPaneId(result, key, args) {
+  const pane = readPane(result[key]);
+  if (pane === void 0) {
+    throw new HerdrError(
+      args,
+      `herdr response had no ${key}.pane_id: ${JSON.stringify(result)}`,
+      "",
+      0
+    );
+  }
+  assertValidPaneId2(pane.paneId);
+  return pane.paneId;
 }
-var LEGACY_LOG_ONLY_SQL_EXCLUSION = `(intent IS NULL OR intent NOT IN (${[
-  ...LEGACY_LOG_ONLY_INTENTS
-].map((i) => `'${i}'`).join(", ")}))`;
-
-// src/logs.ts
-var SELECT_LOG_COLS = `
-  l.seq AS seq,
-  l.key AS workstream,
-  l.actor AS source,
-  l.intent AS intent,
-  l.group_id AS group_id,
-  l.op AS op,
-  l.entity AS kind,
-  l.payload AS payload,
-  l.created_at AS created_at
-`;
-var LOG_FROM_JOIN = "FROM ops l";
-function workstreamScopeSql(column = "l.key") {
-  return `(${column} = ? OR ${column} LIKE ? ESCAPE '\\')`;
+function isHerdrStatusUsable(stdout) {
+  if (!/^\s*status:\s*running\s*$/m.test(stdout)) return false;
+  if (/^\s*endpoint_compatible:\s*no\s*$/m.test(stdout)) return false;
+  return !/^\s*compatible:\s*no\s*$/m.test(stdout);
 }
-function workstreamScopeParams(workstream) {
-  const escaped = workstream.replace(/[\\%_]/g, (c) => `\\${c}`);
-  return [workstream, `${escaped}/%`];
+async function herdrAvailable() {
+  const result = await currentExecutor2(["status"]).catch(() => void 0);
+  if (result === void 0 || result.exitCode !== 0) return false;
+  return isHerdrStatusUsable(result.stdout);
 }
-var TOUCH_OP_FILTER = `NOT (
-  l.intent IS NOT NULL
-  AND l.op = 'put'
-  AND l.payload LIKE '{"updated_at":%'
-  AND LENGTH(l.payload) < 45
-)`;
-var MACHINE_WIDE_KEY = "";
-var GroupIdAmbiguousError = class extends Error {
-  constructor(prefix, candidates) {
-    super(
-      `group id ${JSON.stringify(prefix)} is ambiguous: matches ${candidates.length} groups (${candidates.slice(0, 4).map((c) => c.slice(0, 12)).join(", ")}${candidates.length > 4 ? ", \u2026" : ""})`
-    );
-    this.prefix = prefix;
-    this.candidates = candidates;
-    this.name = "GroupIdAmbiguousError";
-  }
-  prefix;
-  candidates;
-  errorNextSteps() {
-    return [
-      { intent: "List recent groups with their ids", command: "mu undo" },
-      {
-        intent: "Retry with more characters",
-        command: `mu log --group ${this.candidates[0] ?? "<full-id>"}`
-      }
-    ];
+function attachHint2(target) {
+  if (target.window !== void 0) {
+    return `herdr session attach ${target.session} # then focus tab ${target.window}`;
   }
-};
-function groupIdFromPrefix(db, prefix) {
-  if (prefix === "") return null;
-  const rows = db.prepare(
-    `SELECT DISTINCT group_id AS groupId FROM ops
-        WHERE group_id = @exact OR group_id LIKE @prefix || '%' ESCAPE '\\'`
-  ).all({ exact: prefix, prefix: prefix.replace(/[\\%_]/g, (c) => `\\${c}`) });
-  const exact = rows.find((r) => r.groupId === prefix);
-  if (exact !== void 0) return exact.groupId;
-  const first = rows[0];
-  if (rows.length === 1 && first !== void 0) return first.groupId;
-  if (rows.length === 0) return null;
-  throw new GroupIdAmbiguousError(
-    prefix,
-    rows.map((r) => r.groupId)
-  );
+  return `herdr session attach ${target.session}`;
 }
-function machineId(db) {
-  const row = db.prepare("SELECT machine_id FROM machine_identity WHERE id = 1").get();
-  return row?.machine_id ?? "unknown";
+function attachCommands2(target) {
+  return [{ command: "herdr", args: ["session", "attach", target.session] }];
 }
-function rowFromDb(row) {
-  return {
-    seq: row.seq,
-    workstreamName: row.workstream === MACHINE_WIDE_KEY ? null : row.workstream,
-    source: row.source ?? "system",
-    intent: row.intent,
-    group: row.group_id,
-    op: row.op,
-    kind: row.kind,
-    payload: row.payload,
-    createdAt: row.created_at
-  };
+function paneNotFoundNextSteps2(paneId) {
+  return [
+    {
+      intent: `Verify the pane id ${paneId} actually exists`,
+      command: `herdr pane get ${paneId}`
+    },
+    {
+      intent: "List panes in the current workspace",
+      command: 'herdr pane list --workspace "$HERDR_WORKSPACE_ID"'
+    }
+  ];
 }
-function appendLog(db, opts) {
-  const kind = opts.kind ?? "message";
-  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  const key = opts.workstream ?? MACHINE_WIDE_KEY;
-  const group = randomUUID2();
-  const result = db.prepare(
-    `INSERT INTO ops (hlc, machine_id, group_id, actor, intent, entity, key, op, payload, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, 'put', ?, ?)`
-  ).run(
-    nextHlc(db),
-    machineId(db),
-    group,
-    opts.source,
-    opts.intent ?? null,
-    kind,
-    key,
-    opts.payload,
-    createdAt
-  );
+async function healthCheck2() {
+  let version = null;
+  try {
+    const result = await currentExecutor2(["status"]);
+    if (result.exitCode === 0) {
+      const match = /^\s*version:\s*(\S+)\s*$/m.exec(result.stdout);
+      version = match?.[1] ?? null;
+    }
+  } catch {
+    version = null;
+  }
   return {
-    seq: Number(result.lastInsertRowid),
-    workstreamName: opts.workstream,
-    source: opts.source,
-    intent: opts.intent ?? null,
-    group,
-    op: "put",
-    kind,
-    payload: opts.payload,
-    createdAt
+    name: "herdr",
+    ok: version !== null,
+    version,
+    env: [
+      { name: "$HERDR_ENV", value: process.env.HERDR_ENV ?? null },
+      { name: "$HERDR_WORKSPACE_ID", value: process.env.HERDR_WORKSPACE_ID ?? null },
+      { name: "$HERDR_PANE_ID", value: process.env.HERDR_PANE_ID ?? null }
+    ],
+    remediation: "start the herdr server (herdr status) or install herdr"
   };
 }
-function listLogs(db, opts = {}) {
-  const conditions = [];
-  const params = [];
-  if (opts.workstream === null) {
-    conditions.push("l.key = ?");
-    params.push(MACHINE_WIDE_KEY);
-  } else if (opts.workstream !== void 0) {
-    conditions.push(workstreamScopeSql());
-    params.push(...workstreamScopeParams(opts.workstream));
-  }
-  if (opts.since !== void 0) {
-    conditions.push("l.seq > ?");
-    params.push(opts.since);
-  }
-  if (opts.source !== void 0) {
-    conditions.push("l.actor = ?");
-    params.push(opts.source);
-  }
-  if (opts.kind !== void 0) {
-    conditions.push("l.entity = ?");
-    params.push(opts.kind);
-  }
-  if (opts.intent !== void 0) {
-    const spellings = intentSpellings(opts.intent);
-    conditions.push(`l.intent IN (${spellings.map(() => "?").join(", ")})`);
-    params.push(...spellings);
-  }
-  if (opts.group !== void 0) {
-    conditions.push("l.group_id = ?");
-    params.push(opts.group);
+var herdrBackend = Object.freeze({
+  name: "herdr",
+  available: herdrAvailable,
+  isValidPaneId: isValidPaneId2,
+  assertValidPaneId: assertValidPaneId2,
+  listSessions: listSessions2,
+  sessionExists: sessionExists2,
+  newSession: newSession2,
+  newSessionWithPane: newSessionWithPane2,
+  killSession: killSession2,
+  listWindows: listWindows2,
+  newWindow: newWindow2,
+  selectLayout: selectLayout2,
+  listPanes: listPanes2,
+  listPanesInSession: listPanesInSession2,
+  splitWindow: splitWindow2,
+  killPane: killPane2,
+  paneExists: paneExists2,
+  paneTTY: paneTTY2,
+  setPaneTitle: setPaneTitle2,
+  getPaneTitle: getPaneTitle2,
+  currentAgentName: currentAgentName2,
+  currentSessionName: currentSessionName2,
+  startAgentInPane,
+  sendToPane: sendToPane2,
+  capturePane: capturePane2,
+  paneStatus,
+  enableMuPaneBordersForSession: enableMuPaneBordersForSession2,
+  enableMuPaneBordersForPane: enableMuPaneBordersForPane2,
+  attachHint: attachHint2,
+  attachCommands: attachCommands2,
+  paneNotFoundNextSteps: paneNotFoundNextSteps2,
+  healthCheck: healthCheck2
+});
+
+// src/mux/detect.ts
+var BACKENDS = [tmuxBackend, herdrBackend];
+function muxByName(name) {
+  for (const backend of BACKENDS) {
+    if (backend.name === name) return backend;
   }
-  conditions.push(TOUCH_OP_FILTER);
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  if (opts.limit !== void 0 && opts.since === void 0) {
-    const rowsDesc = db.prepare(`SELECT ${SELECT_LOG_COLS} ${LOG_FROM_JOIN} ${where} ORDER BY l.seq DESC LIMIT ?`).all(...params, opts.limit);
-    return rowsDesc.reverse().map(rowFromDb);
+  throw new Error(`unknown mux backend: ${name}`);
+}
+var KNOWN_NAMES = BACKENDS.map((b) => b.name);
+async function detectMux() {
+  const override = process.env.MU_MUX;
+  if (override !== void 0 && override.length > 0) {
+    return muxByName(override);
   }
-  let sql = `SELECT ${SELECT_LOG_COLS} ${LOG_FROM_JOIN} ${where} ORDER BY l.seq ASC`;
-  if (opts.limit !== void 0) {
-    sql += " LIMIT ?";
-    params.push(opts.limit);
+  if (process.env.HERDR_ENV === "1") return herdrBackend;
+  if (process.env.TMUX || process.env.TMUX_PANE) return tmuxBackend;
+  for (const backend of BACKENDS) {
+    if (await backend.available()) return backend;
   }
-  const rows = db.prepare(sql).all(...params);
-  return rows.map(rowFromDb);
-}
-function latestSeq(db, workstream) {
-  const row = workstream === void 0 ? db.prepare(`SELECT MAX(seq) AS s FROM ops l WHERE ${TOUCH_OP_FILTER}`).get() : db.prepare(
-    `SELECT MAX(seq) AS s FROM ops l WHERE ${workstreamScopeSql()} AND ${TOUCH_OP_FILTER}`
-  ).get(...workstreamScopeParams(workstream));
-  return row.s ?? 0;
+  throw new NoMultiplexerError(KNOWN_NAMES);
 }
-function emitEvent(db, workstream, intent, payload, source = "system") {
-  appendLog(db, { workstream, source, kind: entityForIntent(intent), payload, intent });
+var cached;
+async function activeMux() {
+  if (cached === void 0) cached = await detectMux();
+  return cached;
 }
-function entityForIntent(intent) {
-  const dot = intent.indexOf(".");
-  return dot === -1 ? intent : intent.slice(0, dot);
+function setMuxForTests(backend) {
+  const previous = cached;
+  cached = backend;
+  return previous;
 }
-function lastClaimOp(db, workstream, localId) {
-  const row = db.prepare(
-    `SELECT actor, created_at FROM ops
-        WHERE key = ? AND intent = 'task.claim'
-        ORDER BY seq DESC LIMIT 1`
-  ).get(`${workstream}/${localId}`);
-  return row ?? null;
+function resetMux() {
+  cached = void 0;
 }
-function lastClaimEventAt(db, workstream, localId) {
-  return lastClaimOp(db, workstream, localId)?.created_at ?? null;
+
+// src/agents/spawn.ts
+import { execFile as execFile2 } from "child_process";
+import { mkdirSync as mkdirSync2, rmSync as rmSync4 } from "fs";
+import { basename, dirname as dirname6 } from "path";
+import { setTimeout as delay } from "timers/promises";
+import { promisify as promisify2 } from "util";
+
+// src/agents.ts
+import { dirname as dirname5 } from "path";
+
+// src/glyphs.ts
+var AGENT_STATE_GLYPH = {
+  busy: "\uF04B",
+  // nf-fa-play
+  needs_input: "\uF186",
+  // nf-fa-moon_o
+  needs_permission: "\uF023",
+  // nf-fa-lock
+  unknown: "\uF059"
+  // nf-fa-question_circle
+};
+function agentStateGlyph(state) {
+  return AGENT_STATE_GLYPH[state] ?? GLYPH.unknown;
 }
+var GLYPH = {
+  /** Healthy, clean, passing, closed-successfully. */
+  ok: "\uF058",
+  // nf-fa-check_circle
+  /** Failed check. */
+  fail: "\uF057",
+  // nf-fa-times_circle
+  /** Needs attention but not broken (idle-but-assigned, stale warning). */
+  warn: "\uF071",
+  // nf-fa-warning
+  /** Workspace has uncommitted edits. */
+  dirty: "\uF005",
+  // nf-fa-star
+  /** Workspace is ≥ WORKSPACE_STALE_THRESHOLD commits behind main. */
+  stale: "\uF017",
+  // nf-fa-clock_o
+  /** Task is blocked by an incoming edge. */
+  blocked: "\uF0C1",
+  // nf-fa-link (chain)
+  /** Task is parked (OPEN/parked): open, but set aside on purpose. */
+  parked: "\uF04C",
+  // nf-fa-pause
+  /** Track whose roots merged (diamond dependency). */
+  merge: "\uF074",
+  // nf-fa-random
+  /** Agent owns more than one task (pane-title multi-count slot). */
+  multi: "\uF055",
+  // nf-fa-plus_circle
+  /** Filter toggle: enabled / disabled. */
+  on: "\uF111",
+  // nf-fa-circle
+  off: "\uF10C",
+  // nf-fa-circle_o
+  /** Status outside the known enum. */
+  unknown: "\uF059"
+  // nf-fa-question_circle
+};
 
 // src/op-context.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -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
@@ -5296,12 +5332,32 @@ function recordReasonNote(db, localId, workstream, substate, why, author) {
   if (why === void 0 || why.trim() === "") return;
   const noteOpts = { workstream };
   if (author !== void 0 && author !== "") noteOpts.author = author;
-  insertNote(db, localId, `${substate.toUpperCase()}: ${why}`, noteOpts);
+  const text = substate === "rejected" || substate === "superseded" ? withTitles(db, why, workstream, localId) : why;
+  insertNote(db, localId, `${substate.toUpperCase()}: ${text}`, noteOpts);
+}
+var TASK_ID_TOKEN = /(?<![\w./-])[a-z][a-z0-9_-]{0,63}(?![\w-]|\.\w|:\d)/g;
+var TASK_ID_WITH_PAREN = new RegExp(`(?:${TASK_ID_TOKEN.source})(\\s*\\()?`, "g");
+function namedTaskIds(db, text, workstream, self) {
+  const ids = (text.match(TASK_ID_TOKEN) ?? []).filter((t) => t !== self);
+  return [...new Set(ids)].filter((t) => getTask(db, t, workstream) !== void 0);
+}
+function withTitles(db, why, workstream, self) {
+  const named = new Set(namedTaskIds(db, why, workstream, self));
+  if (named.size === 0) return why;
+  return why.replace(TASK_ID_WITH_PAREN, (match, paren) => {
+    const id = paren === void 0 ? match : match.slice(0, -paren.length);
+    if (!named.has(id)) return match;
+    const title = getTask(db, id, workstream)?.title ?? "";
+    return paren === void 0 ? `${id} (${title})` : `${id} (${title}; `;
+  });
 }
 function openTask(db, localId, opts) {
-  return withOpContext(db, { intent: "task.open", group: "new" }, () => {
+  return withOpContext(db, { intent: "task.open", actor: opts.author, group: "new" }, () => {
     const before = getTask(db, localId, opts.workstream);
-    const r = setTaskStatus(db, localId, "OPEN", opts);
+    const r = setTaskStatus(db, localId, "OPEN", {
+      workstream: opts.workstream,
+      ...opts.evidence !== void 0 ? { evidence: opts.evidence } : {}
+    });
     if (r.changed && before) recordEvidenceNote(db, localId, before.workstreamName, "OPEN", opts);
     return r;
   });
@@ -5332,7 +5388,7 @@ function parkTask(db, localId, opts) {
 function acceptTask(db, localId, opts) {
   return withOpContext(
     db,
-    { intent: "task.accept", group: "new" },
+    { intent: "task.accept", actor: opts.author, group: "new" },
     () => db.transaction(() => {
       const before = getTask(db, localId, opts.workstream);
       if (!before) throw new TaskNotFoundError(localId);
@@ -5354,7 +5410,7 @@ function acceptTask(db, localId, opts) {
 function unparkTask(db, localId, opts) {
   return withOpContext(
     db,
-    { intent: "task.unpark", group: "new" },
+    { intent: "task.unpark", actor: opts.author, group: "new" },
     () => db.transaction(() => {
       const before = getTask(db, localId, opts.workstream);
       if (!before) throw new TaskNotFoundError(localId);
@@ -5378,7 +5434,7 @@ function unparkTask(db, localId, opts) {
 function releaseTask(db, localId, opts) {
   return withOpContext(
     db,
-    { intent: "task.release", group: "new" },
+    { intent: "task.release", actor: opts.author, group: "new" },
     () => releaseTaskImpl(db, localId, opts)
   );
 }
@@ -5466,7 +5522,10 @@ async function claimTaskImpl(db, localId, opts) {
       }
       const after = getTask(db, localId, opts.workstream);
       if (!after) throw new Error(`claimTask: row missing after update: ${localId}`);
-      recordEvidenceNote(db, localId, opts.workstream, "CLAIM", opts);
+      recordEvidenceNote(db, localId, opts.workstream, "CLAIM", {
+        ...opts,
+        author: opts.author ?? agentName
+      });
       return {
         ownerName: agentName,
         actorName: agentName,
@@ -5526,7 +5585,10 @@ async function claimSelf(db, localId, opts) {
       }
       const after = getTask(db, localId, before.workstreamName);
       if (!after) throw new Error(`claimTask: row missing after update: ${localId}`);
-      recordEvidenceNote(db, localId, before.workstreamName, "CLAIM", opts);
+      recordEvidenceNote(db, localId, before.workstreamName, "CLAIM", {
+        ...opts,
+        author: opts.author ?? actor
+      });
       return {
         ownerName: null,
         actorName: actor,
@@ -5601,12 +5663,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 +5701,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 +5723,8 @@ async function waitForTasks(db, input, opts) {
             owner,
             ref.workstreamName,
             ageSecs,
-            ctlOwners.has(`${ref.workstreamName}/${owner ?? ""}`)
+            ctlOwners.has(`${ref.workstreamName}/${owner ?? ""}`),
+            runs
           );
         }
       }
@@ -5710,6 +5779,7 @@ async function abortAgent(db, name, opts) {
   const st = await ctlRequestFor(agent, sock, { op: "status" });
   if (!st.ok) throw new Error(`control socket refused status: ${st.error}`);
   const before = st.state ?? "idle";
+  const pending = st.pending ?? false;
   if (before !== "busy") {
     return {
       ...base,
@@ -5717,6 +5787,7 @@ async function abortAgent(db, name, opts) {
       after: before,
       settled: true,
       aborted: false,
+      pending,
       elapsedMs: Date.now() - started
     };
   }
@@ -5733,9 +5804,50 @@ async function abortAgent(db, name, opts) {
     after: w.state ?? "idle",
     settled: true,
     aborted: true,
+    pending,
     elapsedMs: Date.now() - started
   };
 }
+async function interruptAgent(db, name, text, opts) {
+  const r = await interruptAgentImpl(db, name, text, opts);
+  recordSend(db, { name, workstreamName: opts.workstream }, "interrupt", text.length, {
+    transport: "ctl",
+    wasBusy: r.wasBusy
+  });
+  return r;
+}
+async function interruptAgentImpl(db, name, text, opts) {
+  const agent = getAgent(db, name, opts.workstream);
+  if (!agent) throw new AgentNotFoundError(name, opts.workstream);
+  const sock = opts.socket ?? agentCtlSocket(db, agent);
+  if (!expectsCtl(agent, sock)) throw new AgentAbortNeedsCtlError(name, opts.workstream, agent.cli);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_ABORT_TIMEOUT_MS;
+  let r;
+  try {
+    r = await ctlRequest(sock, { op: "interrupt", text, timeoutMs });
+  } catch (e) {
+    if (!(e instanceof CtlUnknownOpError)) throw await ctlFailure(agent, sock, e);
+    const ab = await abortAgent(db, name, { ...opts, socket: sock });
+    const sent = await ctlRequestFor(agent, sock, { op: "send", text });
+    if (!sent.ok) throw new Error(`control socket refused the send: ${sent.error}`);
+    return {
+      wasBusy: ab.aborted,
+      pending: ab.pending,
+      ...sent.runs !== void 0 ? { runs: sent.runs } : {},
+      fallback: true
+    };
+  }
+  if (!r.ok) {
+    if (r.error === "timeout") throw new AgentAbortTimeoutError(name, opts.workstream, timeoutMs);
+    throw new Error(`control socket refused the interrupt: ${r.error}`);
+  }
+  return {
+    wasBusy: r.wasBusy ?? false,
+    pending: r.pending ?? false,
+    ...r.runs !== void 0 ? { runs: r.runs } : {},
+    fallback: false
+  };
+}
 
 // src/agents/adopt.ts
 var ADOPT_CTL_PROBE_MS = 1e3;
@@ -6089,13 +6201,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,
@@ -6135,10 +6240,23 @@ function isValidAgentName(name) {
 async function sendToAgent(db, name, text, opts) {
   const agent = getAgent(db, name, opts.workstream);
   if (!agent) throw new AgentNotFoundError(name);
-  return sendViaTransport(agent, text, {
+  const sent = await sendViaTransport(agent, text, {
     ...opts,
     socket: opts.socket ?? agentCtlSocket(db, agent)
   });
+  recordSend(
+    db,
+    agent,
+    opts.fresh ? "fresh" : opts.mode === "steer" ? "steer" : "plain",
+    text.length,
+    {
+      transport: sent.transport,
+      command: sent.command,
+      state: sent.state,
+      since: sent.since
+    }
+  );
+  return sent;
 }
 async function readAgent(db, name, opts) {
   const agent = getAgent(db, name, opts.workstream);
@@ -6191,7 +6309,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 +6574,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 +6582,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 +6610,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 +6622,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 +6644,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 +6669,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 +6803,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 +6969,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 +6978,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 +7037,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 +7125,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 +7215,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 +7223,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 +7295,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,22 +7323,34 @@ 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 {
     return await ctlRequest(sock, req);
   } catch (e) {
-    if (e instanceof CtlVersionError) throw e;
-    if (e instanceof CtlUnknownOpError) throw await extensionOutdated(agent, sock, e);
-    throw new AgentCtlUnreachableError(
-      agent.name,
-      agent.workstreamName,
-      sock,
-      errCode(e) === "ENOENT" ? "missing" : "refused"
-    );
+    throw await ctlFailure(agent, sock, e);
   }
 }
+async function ctlFailure(agent, sock, e) {
+  if (e instanceof CtlVersionError) return e;
+  if (e instanceof CtlUnknownOpError) return extensionOutdated(agent, sock, e);
+  return new AgentCtlUnreachableError(
+    agent.name,
+    agent.workstreamName,
+    sock,
+    errCode(e) === "ENOENT" ? "missing" : "refused"
+  );
+}
+function recordSend(db, agent, mode, bytes, fields2) {
+  const detail = Object.entries({ mode, ...fields2 }).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${k === "since" ? new Date(Number(v)).toISOString() : v}`).join(" ");
+  emitEvent(
+    db,
+    agent.workstreamName,
+    "agent.send",
+    `agent send ${agent.name} (${detail}, ${bytes} bytes)`
+  );
+}
 async function sendViaTransport(agent, text, opts) {
   const sock = opts.socket;
   if (opts.fresh && (opts.via === "mux" || !expectsCtl(agent, sock))) {
@@ -7225,7 +7384,12 @@ 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 } : {},
+    ...reply.since !== void 0 ? { since: reply.since } : {}
+  };
 }
 async function runSessionCommand(agent, sock, cmd, force) {
   const reply = await ctlRequestFor(agent, sock, {
@@ -7427,7 +7591,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 +8243,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 +8253,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 +8316,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 +8838,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 +8868,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 +8904,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 +8915,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 +8923,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 +8957,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 +9136,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 +9149,7 @@ function murmurVersion(executable) {
       } catch {
       }
     }
-    dir = dirname9(dir);
+    dir = dirname10(dir);
   }
   return null;
 }
@@ -9020,7 +9185,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 +9294,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 [
@@ -9292,6 +9460,7 @@ var VERBS = {
   "agent.close": "agent close",
   "agent.adopt": "agent adopt",
   "agent.kick": "agent kick",
+  "agent.send": "agent send",
   // Payload prose reads "agent stalled ..."; keep the verb matching it
   // so the emitted text is not printed with a second, different verb.
   "agent.stall": "agent stalled",
@@ -9414,6 +9583,7 @@ function renderKnown(row, intent) {
     case "agent.close":
     case "agent.adopt":
     case "agent.kick":
+    case "agent.send":
     case "agent.stall":
     case "workspace.create":
     case "workspace.free":
@@ -11167,6 +11337,7 @@ export {
   insertAgent,
   inspectLinks,
   installCapture,
+  interruptAgent,
   isKickSignal,
   isPathInside,
   isTaskStatus,