@mu-crew/mu 3.1.0 → 3.2.1

package/dist/extension/mu-pi.js

@@ -0,0 +1,786 @@
+// extension/mu-pi.ts
+import {
+  chmodSync,
+  existsSync as existsSync2,
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  statSync as statSync2
+} from "fs";
+import { connect, createServer } from "net";
+import { dirname, join as join2 } from "path";
+
+// src/ctl/protocol.ts
+var CTL_PROTOCOL_VERSION = 1;
+var CTL_OPS = [
+  "hello",
+  "status",
+  "send",
+  "wait",
+  "abort",
+  "fresh"
+];
+var UNKNOWN_OP_PREFIX = "unknown op: ";
+function encode(msg) {
+  return `${JSON.stringify(msg)}
+`;
+}
+var LineDecoder = class {
+  buf = "";
+  push(chunk) {
+    this.buf += chunk;
+    const parts = this.buf.split("\n");
+    this.buf = parts.pop() ?? "";
+    return parts;
+  }
+};
+
+// extension/delegate.ts
+import { execFile } from "child_process";
+import { existsSync, statSync } from "fs";
+import { delimiter, join } from "path";
+import { fileURLToPath } from "url";
+var DELEGATE_TOOL = "mu_delegate";
+var DELEGATE_CANCEL_TOOL = "mu_delegate_cancel";
+var DELEGATE_MESSAGE_TYPE = "mu-delegate";
+var DELEGATE_WORKSTREAM = "scratch";
+var DELEGATE_STATUS_KEY = "mu-delegate";
+function delegateStatus(n) {
+  return n > 0 ? `${n} delegate${n === 1 ? "" : "s"} running` : void 0;
+}
+var DELEGATE_TIMEOUT_S = 3600;
+var W = DELEGATE_WORKSTREAM;
+function delegateEnabled(env = process.env) {
+  if (env.MU_MANAGED_AGENT) return false;
+  if (env.MU_DELEGATE === "0") return false;
+  if (env.MU_MUX || env.HERDR_ENV === "1" || env.TMUX || env.TMUX_PANE) return true;
+  return onPath("tmux", env) || onPath("herdr", env);
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function onPath(bin, env) {
+  return (env.PATH ?? "").split(delimiter).some((d) => d !== "" && existsSync(join(d, bin)));
+}
+function defaultRunner() {
+  let cli;
+  try {
+    const p = fileURLToPath(new URL("../cli.js", import.meta.url));
+    if (existsSync(p)) cli = p;
+  } catch {
+  }
+  return (args, signal) => new Promise((resolve) => {
+    const [cmd, argv] = cli ? [process.execPath, [cli, ...args]] : ["mu", [...args]];
+    execFile(
+      cmd,
+      argv,
+      { maxBuffer: 16 * 1024 * 1024, ...signal ? { signal } : {} },
+      (err, stdout, stderr) => {
+        const code = err ? typeof err.code === "number" ? err.code : 1 : 0;
+        resolve({ code, stdout: String(stdout), stderr: String(stderr || err?.message || "") });
+      }
+    );
+  });
+}
+function formatElapsed(ms) {
+  const t = Math.max(0, Math.round(ms / 1e3));
+  if (t < 60) return `${t}s`;
+  const m = Math.floor(t / 60);
+  if (m < 60) return `${m}m ${String(t % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
+}
+function delegateMessage(name, agent, pane, x = {}) {
+  const timeoutS = x.timeoutS ?? DELEGATE_TIMEOUT_S;
+  const who = `Delegate ${W}/${name}`;
+  const took = x.elapsedMs !== void 0 ? ` after ${formatElapsed(x.elapsedMs)}` : "";
+  const fate = pane.closed ? "Pane closed." : `Pane kept (${pane.why}).`;
+  const look = [
+    x.attach ? `Attach: ${x.attach}` : void 0,
+    `Read: mu agent read ${name} -n 50 -w ${W}`
+  ].filter((v) => v !== void 0);
+  const tailBlock = x.tail?.trim() ? `
+
+Pane tail:
+${x.tail.trimEnd()}` : "";
+  const ws = x.workspace ? ` Workspace: ${x.workspace}` : "";
+  switch (agent?.outcome) {
+    case "done":
+      return `${who} finished${took}. ${fate}${ws}
+
+${agent.lastText ?? ""}`;
+    case "empty":
+      return `${who} finished${took} without a text answer. ${fate}${ws}${tailBlock}`;
+    case "died":
+      return `${who} died${took} before answering. ${fate}${ws}${tailBlock}`;
+    case "timeout":
+    case "pending":
+      return [
+        `${who} is still running after ${timeoutS}s; stopped waiting, so its answer will not arrive here. ${fate}${ws}`,
+        ...look,
+        `Wait again: mu agent wait ${name} -w ${W} --json`
+      ].join("\n");
+    default:
+      return `${who}: mu agent wait gave no result. ${fate}${ws}${tailBlock}`;
+  }
+}
+function labelStem(label) {
+  if (typeof label !== "string") return void 0;
+  const stem = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 20).replace(/-+$/, "");
+  return stem || void 0;
+}
+function registerDelegate(pi, run = defaultRunner()) {
+  if (!delegateEnabled()) return;
+  const inflight = /* @__PURE__ */ new Map();
+  const reserved = /* @__PURE__ */ new Set();
+  let ui;
+  const showStatus = () => {
+    try {
+      ui?.setStatus?.(DELEGATE_STATUS_KEY, delegateStatus(inflight.size));
+    } catch {
+    }
+  };
+  const track = (ctx) => {
+    if (ctx?.hasUI !== false && ctx?.ui) ui = ctx.ui;
+  };
+  const forget = (name) => {
+    inflight.delete(name);
+    reserved.delete(name);
+    showStatus();
+  };
+  const mu = run;
+  const json = (r) => {
+    try {
+      const v = JSON.parse(r.stdout);
+      return typeof v === "object" && v !== null ? v : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const failure = (what, r) => new Error(`${what} failed (exit ${r.code}): ${(r.stderr || r.stdout).trim()}`);
+  async function pickName(stem) {
+    const r = await mu(["agent", "list", "-w", W, "--json"]);
+    const agents = json(r)?.agents;
+    const taken = new Set(
+      Array.isArray(agents) ? agents.map((a) => a.name).filter((n) => n) : []
+    );
+    for (let n = 1; ; n++) {
+      const name = stem ? n === 1 ? `delegate-${stem}` : `delegate-${stem}-${n}` : `delegate-${n}`;
+      if (!taken.has(name) && !reserved.has(name)) {
+        reserved.add(name);
+        return name;
+      }
+    }
+  }
+  async function spawn(params, cwd, signal) {
+    const stem = labelStem(params.label);
+    for (let attempt = 0; ; attempt++) {
+      signal?.throwIfAborted();
+      const name = await pickName(stem);
+      const args = ["agent", "spawn", name, "-w", W, "--json"];
+      if (params.workspace === true) args.push("--workspace");
+      else if (cwd) args.push("--cwd", cwd);
+      if (typeof params.cli === "string" && params.cli) args.push("--cli", params.cli);
+      const r = await mu(args);
+      if (signal?.aborted && r.code === 0) {
+        reserved.delete(name);
+        await mu(["agent", "close", name, "-w", W]);
+        signal.throwIfAborted();
+      }
+      if (r.code !== 0 && /already exists/.test(r.stderr) && attempt < 3) {
+        reserved.delete(name);
+        continue;
+      }
+      if (r.code !== 0) {
+        reserved.delete(name);
+        throw failure("mu agent spawn", r);
+      }
+      const out = json(r) ?? {};
+      if (out.ctl !== "ok") {
+        reserved.delete(name);
+        throw new Error(
+          `${W}/${name} spawned but its control socket is ${String(out.ctl)}, so its answer cannot come back. Pane kept; close it with: mu agent close ${name} -w ${W}`
+        );
+      }
+      const steps = Array.isArray(out.nextSteps) ? out.nextSteps : [];
+      const attach = steps.map((s) => s).find((s) => s.intent === "Attach the pane")?.command;
+      const wsPath = out.workspace?.path;
+      return {
+        name,
+        ...typeof attach === "string" ? { attach } : {},
+        ...typeof wsPath === "string" ? { workspace: wsPath } : {}
+      };
+    }
+  }
+  async function deliver(name, wait, keep, extras) {
+    const agent = json(wait)?.agents?.[0];
+    const outcome = agent?.outcome;
+    const tail = outcome === "done" || outcome === "timeout" || outcome === "pending" ? void 0 : (await mu(["agent", "read", name, "-n", "50", "-w", W])).stdout;
+    let pane = { closed: false, why: "keep: true" };
+    if (outcome !== "done" && outcome !== "empty")
+      pane = { closed: false, why: "kept as evidence" };
+    else if (!keep) {
+      const c = await mu(["agent", "close", name, "-w", W]);
+      pane = c.code === 0 ? { closed: true } : { closed: false, why: `close refused: ${(c.stderr || c.stdout).trim()}` };
+    }
+    await pi.sendMessage(
+      {
+        customType: DELEGATE_MESSAGE_TYPE,
+        content: delegateMessage(name, agent, pane, { ...extras, ...tail ? { tail } : {} }),
+        display: true,
+        details: {
+          name,
+          workstream: W,
+          outcome: outcome ?? null,
+          closed: pane.closed,
+          answer: outcome === "done" ? agent?.lastText ?? null : null,
+          elapsedMs: extras.elapsedMs ?? null,
+          workspace: extras.workspace ?? null
+        }
+      },
+      { deliverAs: "followUp", triggerTurn: true }
+    );
+  }
+  pi.registerTool({
+    name: DELEGATE_TOOL,
+    label: "mu delegate",
+    description: `Subagent: run one self-contained task in a fresh pi agent (its own mux pane in mu's ${W} workstream) while you keep working. Use it whenever you would reach for a subagent: research, a review, a draft, an investigation; call it several times to fan out in parallel. The subagent starts with no context, in your working directory: put everything it needs in task. The call returns at once and the answer arrives later as a follow-up message: carry on with other work, or end your turn if your next step needs the answer (the follow-up resumes you). The pane closes after a clean finish; keep: true leaves it open.`,
+    promptSnippet: "Subagent: delegate a self-contained task to a background pi agent; its answer arrives later as a follow-up",
+    parameters: {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "The complete task, with all context it needs" },
+        label: {
+          type: "string",
+          description: "Short label naming the delegate, e.g. 'review' \u2192 delegate-review. Use one per subtask when fanning out."
+        },
+        brief: {
+          type: "string",
+          description: "Optional standing role or rules, sent before the task, e.g. 'You are a reviewer; read only.' The rules are instructions, not enforced. The job itself goes in task."
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory for the delegate (default: yours; ignored with workspace)"
+        },
+        timeout: {
+          type: "number",
+          exclusiveMinimum: 0,
+          description: `Seconds to wait for the answer (default ${DELEGATE_TIMEOUT_S}). On timeout you get a "still running" follow-up instead of the answer, and the answer will not arrive later; the subagent keeps running in its pane.`
+        },
+        workspace: {
+          type: "boolean",
+          description: "For tasks that edit files: its own VCS checkout (jj workspace / git worktree / sl share) branched from the current commit. The result and follow-up name the path; changes stay there until you merge them. This isolates repository edits only: the subagent runs as you, with your files, environment and network."
+        },
+        cli: {
+          type: "string",
+          description: "Agent CLI key (default pi). Name a configured key such as 'pi_fast' to run a cheaper model."
+        },
+        keep: {
+          type: "boolean",
+          description: "Keep the pane after it finishes, to talk to it again"
+        }
+      },
+      required: ["task"],
+      additionalProperties: false
+    },
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      track(ctx);
+      const task = typeof params.task === "string" ? params.task.trim() : "";
+      if (!task) throw new Error("mu_delegate needs a non-empty task");
+      const brief = typeof params.brief === "string" ? params.brief.trim() : "";
+      const keep = params.keep === true;
+      const t = params.timeout;
+      if (t !== void 0 && !(typeof t === "number" && Number.isFinite(t) && t > 0))
+        throw new Error(
+          `mu_delegate: timeout must be a positive number of seconds (got ${JSON.stringify(t)})`
+        );
+      const timeoutS = typeof t === "number" ? Math.ceil(t) : DELEGATE_TIMEOUT_S;
+      let cwd;
+      if (params.workspace !== true) {
+        cwd = typeof params.cwd === "string" && params.cwd ? params.cwd : ctx?.cwd ?? process.cwd();
+        if (!isDir(cwd)) throw new Error(`mu_delegate: cwd ${cwd} is not a directory`);
+      }
+      const { name, attach, workspace } = await spawn(params, cwd, signal);
+      const entry = { abort: new AbortController(), cancelling: false };
+      inflight.set(name, entry);
+      showStatus();
+      const started = Date.now();
+      const waiting = mu(
+        ["agent", "wait", name, "-w", W, "--json", "--timeout", String(timeoutS)],
+        entry.abort.signal
+      );
+      const sent = await mu(["agent", "send", name, brief ? `${brief}
+
+${task}` : task, "-w", W]);
+      if (sent.code !== 0) {
+        entry.abort.abort();
+        forget(name);
+        const c = await mu(["agent", "close", name, "-w", W]);
+        const pane = c.code === 0 ? "Pane closed." : `Pane kept; close it with: mu agent close ${name} -w ${W}`;
+        throw new Error(`${failure(`mu agent send to ${W}/${name}`, sent).message}. ${pane}`);
+      }
+      const settle = async (r) => {
+        forget(name);
+        try {
+          await deliver(name, r, keep, {
+            timeoutS,
+            elapsedMs: Date.now() - started,
+            ...attach ? { attach } : {},
+            ...workspace ? { workspace } : {}
+          });
+        } catch (e) {
+          await Promise.resolve(
+            pi.sendMessage(
+              {
+                customType: DELEGATE_MESSAGE_TYPE,
+                content: `Delegate ${W}/${name} settled, but delivering its answer failed: ${e instanceof Error ? e.message : String(e)}. Read it with: mu agent read ${name} -n 50 -w ${W}`,
+                display: true,
+                details: { name, workstream: W, outcome: null, closed: false }
+              },
+              { deliverAs: "followUp", triggerTurn: true }
+            )
+          ).catch(() => {
+          });
+        }
+      };
+      void waiting.then(async (r) => {
+        if (inflight.get(name) !== entry) return;
+        if (entry.cancelling) entry.parked = () => settle(r);
+        else await settle(r);
+      });
+      const lines = [
+        `Delegated to ${W}/${name}. Its answer arrives as a follow-up message when it finishes; do not wait or poll.`,
+        workspace ? `Workspace: ${workspace}` : void 0,
+        attach ? `Attach: ${attach}` : void 0,
+        `Cancel: ${DELEGATE_CANCEL_TOOL} { name: "${name}" }`
+      ].filter((x) => x !== void 0);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+          name,
+          workstream: W,
+          attach: attach ?? null,
+          workspace: workspace ?? null,
+          keep
+        }
+      };
+    }
+  });
+  pi.registerTool({
+    name: DELEGATE_CANCEL_TOOL,
+    label: "mu delegate cancel",
+    description: `Stop a delegate started by ${DELEGATE_TOOL}: abort its turn and close its pane (keep: true leaves the pane open). No follow-up message is sent for it afterwards.`,
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Delegate name, e.g. delegate-1" },
+        keep: { type: "boolean", description: "Leave the pane open after aborting" }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      track(ctx);
+      const name = typeof params.name === "string" ? params.name : "";
+      if (!name) throw new Error("mu_delegate_cancel needs a name");
+      const entry = inflight.get(name);
+      if (entry) entry.cancelling = true;
+      const ab = await mu(["agent", "abort", name, "-w", W]);
+      if (ab.code !== 0) {
+        if (entry) {
+          entry.cancelling = false;
+          const parked = entry.parked;
+          entry.parked = void 0;
+          if (parked) void parked();
+        }
+        throw failure(`mu agent abort ${W}/${name}`, ab);
+      }
+      if (entry) {
+        entry.abort.abort();
+        forget(name);
+      }
+      let text = `Aborted ${W}/${name}.`;
+      if (params.keep === true) text += " Pane kept.";
+      else {
+        const c = await mu(["agent", "close", name, "-w", W]);
+        text += c.code === 0 ? " Pane closed." : ` Pane kept: close refused: ${(c.stderr || c.stdout).trim()}`;
+      }
+      return { content: [{ type: "text", text }], details: { name, workstream: W } };
+    }
+  });
+  pi.on("session_shutdown", (_e, ctx) => {
+    if (inflight.size === 0) return;
+    const names = [...inflight.keys()];
+    for (const e of inflight.values()) e.abort.abort();
+    inflight.clear();
+    showStatus();
+    ui = void 0;
+    const msg = `${names.length} delegate${names.length === 1 ? "" : "s"} still running: ${names.join(", ")}. Their answers will not come back here; use mu agent wait <name> -w ${W} --json.`;
+    if (ctx?.hasUI && ctx.ui) ctx.ui.notify(msg, "warning");
+    else process.stderr.write(`mu: ${msg}
+`);
+  });
+}
+
+// extension/mu-pi.ts
+var EXT_VERSION = true ? "3.2.1" : void 0;
+var FRESH_COMMAND = "mu-fresh";
+var FRESH_TIMEOUT_MS = 3e4;
+var LAST_TEXT_MAX_BYTES = 64 * 1024;
+var LAST_TEXT_TRUNCATED = "[truncated, see pane]";
+var LIVE_PROBE_MS = 500;
+var V = CTL_PROTOCOL_VERSION;
+function fail(error) {
+  return { v: V, ok: false, error };
+}
+function detectPiVersion() {
+  try {
+    const entry = process.argv[1];
+    if (!entry) return void 0;
+    let dir = dirname(realpathSync(entry));
+    for (let i = 0; i < 6; i++) {
+      const pkgPath = join2(dir, "package.json");
+      if (existsSync2(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (typeof pkg === "object" && pkg !== null) {
+          const { name, version } = pkg;
+          if (typeof name === "string" && /pi/.test(name) && typeof version === "string") {
+            return version;
+          }
+        }
+      }
+      const up = dirname(dir);
+      if (up === dir) break;
+      dir = up;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function str(o, k) {
+  const x = o[k];
+  return typeof x === "string" ? x : void 0;
+}
+function num(o, k) {
+  const x = o[k];
+  return typeof x === "number" && Number.isFinite(x) ? x : void 0;
+}
+var SHARED = /* @__PURE__ */ Symbol.for("mu.pi.ctl");
+function sharedMap() {
+  const g = globalThis;
+  g[SHARED] ??= /* @__PURE__ */ new Map();
+  return g[SHARED];
+}
+function lastAssistantText(event) {
+  const msgs = typeof event === "object" && event !== null ? event.messages : void 0;
+  if (!Array.isArray(msgs)) return "";
+  for (let i = msgs.length - 1; i >= 0; i--) {
+    const m = msgs[i];
+    if (typeof m !== "object" || m === null) continue;
+    const { role, content } = m;
+    if (role !== "assistant") continue;
+    if (typeof content === "string") return capText(content);
+    if (!Array.isArray(content)) return "";
+    const parts = content.flatMap((c) => {
+      if (typeof c !== "object" || c === null) return [];
+      const { type, text } = c;
+      return type === "text" && typeof text === "string" ? [text] : [];
+    });
+    return capText(parts.join(""));
+  }
+  return "";
+}
+function capText(text) {
+  if (Buffer.byteLength(text, "utf8") <= LAST_TEXT_MAX_BYTES) return text;
+  const cut = Buffer.from(text, "utf8").subarray(0, LAST_TEXT_MAX_BYTES).toString("utf8");
+  return `${cut.replace(/\uFFFD$/, "")}
+${LAST_TEXT_TRUNCATED}`;
+}
+function inodeOf(path) {
+  try {
+    return statSync2(path).ino;
+  } catch {
+    return void 0;
+  }
+}
+function socketIsLive(path) {
+  return new Promise((resolve) => {
+    const c = connect(path);
+    const done = (live) => {
+      clearTimeout(timer);
+      c.destroy();
+      resolve(live);
+    };
+    const timer = setTimeout(() => done(true), LIVE_PROBE_MS);
+    c.once("connect", () => done(true));
+    c.once(
+      "error",
+      (e) => done(e.code !== "ENOENT" && e.code !== "ECONNREFUSED")
+    );
+  });
+}
+var bindSeq = 0;
+function reasonOf(event) {
+  const r = typeof event === "object" && event !== null ? event.reason : void 0;
+  return typeof r === "string" ? r : void 0;
+}
+function muPi(pi) {
+  registerDelegate(pi);
+  serveCtl(pi);
+}
+function serveCtl(pi) {
+  const sock = process.env.MU_CTL_SOCK;
+  if (!sock) return;
+  const sockPath = sock;
+  const piVersion = detectPiVersion();
+  const map = sharedMap();
+  const existing = map.get(sockPath);
+  const g = existing ?? {
+    conns: /* @__PURE__ */ new Set(),
+    waiters: /* @__PURE__ */ new Set(),
+    state: "idle",
+    since: Date.now(),
+    runs: 0,
+    lastText: "",
+    pi,
+    handle
+  };
+  g.pi = pi;
+  g.handle = handle;
+  map.set(sockPath, g);
+  const status = () => ({
+    state: g.state,
+    since: g.since,
+    runs: g.runs,
+    pending: g.ctx?.hasPendingMessages() ?? false
+  });
+  const settleFresh = (r) => {
+    const f = g.fresh;
+    if (!f) return;
+    g.fresh = void 0;
+    f.settle(r);
+  };
+  pi.on("agent_start", (_e, c) => {
+    g.ctx = c;
+    g.state = "busy";
+    g.since = Date.now();
+    if (g.fresh?.armed) settleFresh({ v: V, ok: true, ...status() });
+  });
+  pi.on("agent_end", (e) => {
+    g.endText = lastAssistantText(e);
+  });
+  pi.on("agent_settled", (_e, c) => {
+    g.ctx = c;
+    g.state = "idle";
+    g.since = Date.now();
+    g.runs++;
+    g.lastText = g.endText ?? "";
+    g.endText = void 0;
+    for (const w of [...g.waiters]) w();
+  });
+  pi.registerCommand(FRESH_COMMAND, {
+    description: "mu internal: new session + the prompt mu queued (run by mu agent send --fresh)",
+    handler: async (_args, ctx) => {
+      const f = g.fresh;
+      if (!f) return;
+      try {
+        const r = await ctx.newSession({
+          withSession: async (c) => {
+            g.ctx = c;
+            f.armed = true;
+            await c.sendUserMessage(f.text);
+          }
+        });
+        if (r.cancelled) settleFresh(fail("new session was cancelled"));
+      } catch (e) {
+        settleFresh(fail(e instanceof Error ? e.message : String(e)));
+      }
+      settleFresh({ v: V, ok: true, ...status() });
+    }
+  });
+  function fresh(req) {
+    const text = str(req, "text");
+    if (text === void 0) return fail("fresh needs a string text");
+    if (g.fresh) return fail("a fresh send is already in progress");
+    const busy = !(g.ctx?.isIdle() ?? g.state === "idle");
+    if (busy && req.force !== true) return fail("busy");
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => settleFresh(fail("fresh timed out")), FRESH_TIMEOUT_MS);
+      g.fresh = {
+        text,
+        armed: false,
+        settle: (r) => {
+          clearTimeout(timer);
+          resolve(r);
+        }
+      };
+      Promise.resolve(
+        g.pi.sendUserMessage(`/${FRESH_COMMAND}`, { expandPromptTemplates: true })
+      ).catch((e) => settleFresh(fail(e instanceof Error ? e.message : String(e))));
+    });
+  }
+  async function handle(req, conn) {
+    switch (req.op) {
+      case "hello":
+        return {
+          v: V,
+          ok: true,
+          agent: process.env.MU_AGENT_NAME,
+          workstream: process.env.MU_WORKSTREAM,
+          piVersion,
+          ops: [...CTL_OPS],
+          ...EXT_VERSION !== void 0 ? { extVersion: EXT_VERSION } : {}
+        };
+      case "status":
+        return { v: V, ok: true, ...status() };
+      case "send": {
+        const text = str(req, "text");
+        if (text === void 0) return fail("send needs a string text");
+        const mode = req.mode === "steer" ? "steer" : "followUp";
+        if (g.ctx?.isIdle() ?? g.state === "idle") await g.pi.sendUserMessage(text);
+        else await g.pi.sendUserMessage(text, { deliverAs: mode });
+        return { v: V, ok: true, state: g.state };
+      }
+      case "fresh":
+        return fresh(req);
+      case "wait":
+        return wait(num(req, "afterRuns"), num(req, "timeoutMs"), conn);
+      case "abort":
+        if (!g.ctx) return fail("no pi context yet");
+        g.ctx.abort();
+        return { v: V, ok: true, state: g.state };
+      default:
+        return { ...fail(`${UNKNOWN_OP_PREFIX}${String(req.op)}`), ops: [...CTL_OPS] };
+    }
+  }
+  function wait(afterRuns, timeoutMs, conn) {
+    if (afterRuns !== void 0 && g.runs > afterRuns && g.state === "idle") {
+      return Promise.resolve({ v: V, ok: true, ...status(), lastText: g.lastText });
+    }
+    return new Promise((resolve) => {
+      let timer;
+      const done = (r) => {
+        g.waiters.delete(waiter);
+        if (timer) clearTimeout(timer);
+        conn.off("close", onClose);
+        resolve(r);
+      };
+      const waiter = () => done({ v: V, ok: true, ...status(), lastText: g.lastText });
+      const onClose = () => done(fail("client closed"));
+      g.waiters.add(waiter);
+      conn.on("close", onClose);
+      if (timeoutMs !== void 0) timer = setTimeout(() => done(fail("timeout")), timeoutMs);
+    });
+  }
+  function onConnection(conn) {
+    g.conns.add(conn);
+    conn.setEncoding("utf8");
+    const dec = new LineDecoder();
+    let seen = false;
+    conn.on("close", () => g.conns.delete(conn));
+    conn.on("error", () => {
+    });
+    conn.on("data", (chunk) => {
+      const line = dec.push(chunk)[0];
+      if (line === void 0 || seen) return;
+      seen = true;
+      let req;
+      try {
+        req = JSON.parse(line);
+      } catch {
+        conn.end(encode(fail("bad json")));
+        return;
+      }
+      if (typeof req !== "object" || req === null) {
+        conn.end(encode(fail("request must be an object")));
+        return;
+      }
+      g.handle(req, conn).then(
+        (r) => {
+          if (!conn.destroyed) conn.end(encode(r));
+        },
+        (e) => {
+          if (!conn.destroyed) conn.end(encode(fail(e instanceof Error ? e.message : String(e))));
+        }
+      );
+    });
+  }
+  async function bind() {
+    mkdirSync(dirname(sockPath), { recursive: true, mode: 448 });
+    if (await socketIsLive(sockPath)) {
+      process.stderr.write(
+        `mu: control socket ${sockPath} is served by another pi; this pi will not take it
+`
+      );
+      return;
+    }
+    rmSync(sockPath, { force: true });
+    const tmp = join2(dirname(sockPath), `.${process.pid.toString(36)}${(++bindSeq).toString(36)}`);
+    rmSync(tmp, { force: true });
+    const s = createServer(onConnection);
+    await new Promise((resolve, reject) => {
+      s.once("error", reject);
+      s.listen(tmp, () => {
+        s.off("error", reject);
+        resolve();
+      });
+    });
+    chmodSync(tmp, 384);
+    try {
+      linkSync(tmp, sockPath);
+    } catch (e) {
+      s.close();
+      if (e.code !== "EEXIST") throw e;
+      process.stderr.write(`mu: control socket ${sockPath} was taken by another pi
+`);
+      return;
+    } finally {
+      rmSync(tmp, { force: true });
+    }
+    g.server = s;
+    g.ino = inodeOf(sockPath);
+  }
+  pi.on("session_start", async (_e, c) => {
+    g.ctx = c;
+    const s = g.server;
+    if (s) {
+      if (g.ino !== void 0 && inodeOf(sockPath) === g.ino) return;
+      g.server = void 0;
+      g.ino = void 0;
+      s.close();
+    }
+    await bind();
+  });
+  pi.on("session_shutdown", async (e) => {
+    const reason = reasonOf(e);
+    if (reason === "new" || reason === "resume" || reason === "fork" || reason === "reload") {
+      return;
+    }
+    const s = g.server;
+    const ino = g.ino;
+    g.server = void 0;
+    g.ino = void 0;
+    map.delete(sockPath);
+    if (!s) return;
+    g.waiters.clear();
+    settleFresh(fail("pi is shutting down"));
+    for (const c of g.conns) c.destroy();
+    await new Promise((resolve) => s.close(() => resolve()));
+    if (ino !== void 0 && inodeOf(sockPath) === ino) rmSync(sockPath, { force: true });
+  });
+}
+export {
+  FRESH_COMMAND,
+  FRESH_TIMEOUT_MS,
+  LAST_TEXT_MAX_BYTES,
+  LAST_TEXT_TRUNCATED,
+  LIVE_PROBE_MS,
+  muPi as default,
+  lastAssistantText
+};
+//# sourceMappingURL=mu-pi.js.map