@mu-crew/mu 3.2.1 → 3.3.0

package/dist/index.js

@@ -19,6 +19,7 @@ import { createConnection } from "net";
 
 // src/ctl/protocol.ts
 var CTL_PROTOCOL_VERSION = 1;
+var CTL_COMMANDS = ["new", "reload", "compact"];
 var UNKNOWN_OP_PREFIX = "unknown op: ";
 function encode(msg) {
   return `${JSON.stringify(msg)}
@@ -66,7 +67,7 @@ var CtlUnknownOpError = class extends Error {
 };
 function clientTimeout(req, override) {
   if (override !== void 0) return override;
-  if (req.op === "fresh") return CTL_FRESH_TIMEOUT_MS;
+  if (req.op === "fresh" || req.op === "command") return CTL_FRESH_TIMEOUT_MS;
   if (req.op !== "wait") return CTL_DEFAULT_TIMEOUT_MS;
   return req.timeoutMs === void 0 ? void 0 : req.timeoutMs + CTL_WAIT_SLACK_MS;
 }
@@ -1339,27 +1340,6 @@ async function awaitPaneQuiescence(paneId, budgetMs) {
     await currentSleep(Math.min(SEND_READINESS_POLL_MS, remaining));
   }
 }
-async function awaitNewSession(paneId, baseline, budgetMs) {
-  if (budgetMs <= 0) return true;
-  const deadline = Date.now() + budgetMs;
-  let previous = baseline;
-  let stable = 0;
-  for (; ; ) {
-    const scrollback = await capturePane(paneId, { lines: 50 }).catch(() => void 0);
-    if (scrollback !== void 0 && scrollback !== baseline) {
-      if (scrollback === previous) {
-        stable++;
-        if (stable >= QUIESCENCE_CONFIRMATIONS) return true;
-      } else {
-        stable = 0;
-      }
-      previous = scrollback;
-    }
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) return false;
-    await currentSleep(Math.min(SEND_READINESS_POLL_MS, remaining));
-  }
-}
 function pasteProbe(text) {
   const firstLine = (text.split("\n")[0] ?? "").trim();
   return firstLine.slice(0, 24);
@@ -1387,7 +1367,6 @@ async function sendToPane(paneId, text, opts = {}) {
   assertValidPaneId(paneId);
   const readinessMs = opts.readinessMs ?? defaultSendReadinessMs();
   const quiesced = await awaitPaneQuiescence(paneId, readinessMs);
-  const newSessionBaseline = readinessMs > 0 && text.trim() === "/new" ? await capturePane(paneId, { lines: 50 }).catch(() => void 0) : void 0;
   const copyResult = await currentExecutor(["copy-mode", "-q", "-t", paneId]);
   if (copyResult.exitCode !== 0 && /can't find pane|no current target/i.test(copyResult.stderr)) {
     throw new TmuxError(
@@ -1410,15 +1389,6 @@ async function sendToPane(paneId, text, opts = {}) {
   if (delay2 > 0) await currentSleep(delay2);
   await tmux(["send-keys", "-t", paneId, "Enter"]);
   if (readinessMs <= 0) return;
-  if (newSessionBaseline !== void 0 && !await awaitNewSession(paneId, newSessionBaseline, readinessMs)) {
-    const warn3 = opts.onUndelivered ?? defaultUndeliveredWarning;
-    warn3({
-      paneId,
-      reason: "transition-unconfirmed",
-      message: `send to ${paneId} submitted /new, but the new session did not become ready within ${readinessMs}ms. Wait for the pane to settle before sending more work.`
-    });
-    return;
-  }
   const probe = pasteProbe(text);
   if (probe.length === 0) return;
   for (let attempt = 0; attempt <= SUBMIT_RETRIES; attempt++) {
@@ -6485,7 +6455,7 @@ async function spawnAgent(db, opts) {
     agent = created.row;
     const startAgent = (await activeMux()).startAgentInPane;
     if (startAgent === void 0) {
-      await awaitSpawnLiveness(paneId, opts.name, opts.workstream, command);
+      await awaitSpawnLiveness(paneId, opts.name, command);
     } else {
       await startAgent({ paneId, name: opts.name, cli, command, commandSource });
     }
@@ -6625,7 +6595,7 @@ function detectSpawnStartupError(scrollback) {
   }
   return void 0;
 }
-async function awaitSpawnLiveness(paneId, agentName, workstreamName, command) {
+async function awaitSpawnLiveness(paneId, agentName, command) {
   const ms = defaultSpawnLivenessMs();
   if (ms === 0) return;
   await sleep(ms);
@@ -6640,31 +6610,6 @@ async function awaitSpawnLiveness(paneId, agentName, workstreamName, command) {
       throw new AgentSpawnStartupError(agentName, paneId, matchedLine, scrollback);
     }
   }
-  await awaitSpawnReadiness(paneId, agentName, workstreamName, command);
-}
-function defaultSpawnReadinessMs() {
-  const raw = process.env.MU_SPAWN_READINESS_MS;
-  if (raw === void 0) return 1e4;
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed < 0) return 1e4;
-  return parsed;
-}
-var READINESS_POLL_INTERVAL_MS = 250;
-async function awaitSpawnReadiness(paneId, agentName, workstreamName, command) {
-  const budgetMs = defaultSpawnReadinessMs();
-  if (budgetMs === 0 || !murmurAvailable()) return;
-  const mux = await activeMux();
-  const deadline = Date.now() + budgetMs;
-  const agent = { name: agentName, workstreamName, paneId };
-  while (Date.now() < deadline) {
-    if (!await mux.paneExists(paneId)) {
-      const scrollback = await mux.capturePane(paneId, { lines: 50 }).catch(() => void 0);
-      throw new AgentDiedOnSpawnError(agentName, paneId, scrollback, command);
-    }
-    const reading = (await readAgentStates([agent])).get(agentKey(agent));
-    if (reading?.source === "murmur") return;
-    await sleep(Math.min(READINESS_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
-  }
 }
 async function createOrReusePane(opts) {
   const mux = await activeMux();
@@ -7087,23 +7032,47 @@ var AgentExtensionOutdatedError = class extends Error {
   }
 };
 var AgentBusyError = class extends Error {
-  constructor(agentName, workstream) {
-    super(`agent ${agentName} is busy: --fresh would abandon its running turn`);
+  constructor(agentName, workstream, command) {
+    super(`agent ${agentName} is busy: ${command ?? "--fresh"} would abandon its running turn`);
     this.agentName = agentName;
     this.workstream = workstream;
+    this.command = command;
   }
   agentName;
   workstream;
+  command;
   name = "AgentBusyError";
   errorNextSteps() {
+    const retry = this.command === void 0 ? `mu agent send ${this.agentName} --fresh --force '...' -w ${this.workstream}` : `mu agent send ${this.agentName} '${this.command}' --force -w ${this.workstream}`;
     return [
       {
         intent: "Stop the turn first, then retry",
         command: `mu agent abort ${this.agentName} -w ${this.workstream}`
       },
+      { intent: "Or abandon the turn in one step", command: retry }
+    ];
+  }
+};
+var AgentSlashCommandUnsupportedError = class extends Error {
+  constructor(agentName, workstream, text, supported) {
+    super(
+      `agent ${agentName} runs pi: over the control socket mu runs only ${supported.join(", ")}; ${JSON.stringify(text.split("\n")[0])} is not one of them. Pass --via mux to type it into the pane`
+    );
+    this.agentName = agentName;
+    this.workstream = workstream;
+    this.text = text;
+    this.supported = supported;
+  }
+  agentName;
+  workstream;
+  text;
+  supported;
+  name = "AgentSlashCommandUnsupportedError";
+  errorNextSteps() {
+    return [
       {
-        intent: "Or abandon the turn in one step",
-        command: `mu agent send ${this.agentName} --fresh --force '...' -w ${this.workstream}`
+        intent: "Type it into the pane on purpose (tmux paste; unconfirmed)",
+        command: `mu agent send ${this.agentName} '${this.text.split("\n")[0]}' --via mux -w ${this.workstream}`
       }
     ];
   }
@@ -7116,10 +7085,22 @@ function agentCtlSocket(db, agent) {
 function expectsCtl(agent, sock = ctlSocketPath(agent.workstreamName, agent.name)) {
   return speaksMuCtl(agent.cli, resolveCliCommand(agent.cli)) || existsSync8(sock);
 }
-function chooseTransport(agent, text, sock) {
-  if (text.startsWith("/")) return "mux";
+function chooseTransport(agent, sock) {
   return expectsCtl(agent, sock) ? "ctl" : "mux";
 }
+var CTL_SLASH_COMMANDS = CTL_COMMANDS.map((n) => `/${n}`);
+function parseSessionCommand(text) {
+  const t = text.trim();
+  if (t === "/new") return { name: "new" };
+  if (t === "/reload") return { name: "reload" };
+  const m = /^\/compact(?:\s+([\s\S]*))?$/.exec(t);
+  if (!m) return void 0;
+  const instructions = m[1]?.trim();
+  return instructions ? { name: "compact", instructions } : { name: "compact" };
+}
+function isSlashCommand(text) {
+  return /^\/[A-Za-z][\w:-]*(?:\s|$)/.test(text.trimStart());
+}
 async function extensionOutdated(agent, sock, e) {
   let extVersion;
   try {
@@ -7148,11 +7129,23 @@ async function sendViaTransport(agent, text, opts) {
   if (opts.fresh && (opts.via === "mux" || !expectsCtl(agent, sock))) {
     throw new AgentFreshNeedsCtlError(agent.name, agent.workstreamName, agent.cli);
   }
-  const transport = opts.fresh ? "ctl" : opts.via ?? chooseTransport(agent, text, sock);
+  const transport = opts.fresh ? "ctl" : opts.via ?? chooseTransport(agent, sock);
   if (transport === "mux") {
     await (await activeMux()).sendToPane(agent.paneId, text, opts);
     return { transport };
   }
+  if (!opts.fresh) {
+    const cmd = parseSessionCommand(text);
+    if (cmd) return runSessionCommand(agent, sock, cmd, opts.force === true);
+    if (isSlashCommand(text)) {
+      throw new AgentSlashCommandUnsupportedError(
+        agent.name,
+        agent.workstreamName,
+        text,
+        CTL_SLASH_COMMANDS
+      );
+    }
+  }
   const reply = await ctlRequestFor(
     agent,
     sock,
@@ -7166,6 +7159,25 @@ async function sendViaTransport(agent, text, opts) {
   }
   return reply.state === void 0 ? { transport } : { transport, state: reply.state };
 }
+async function runSessionCommand(agent, sock, cmd, force) {
+  const reply = await ctlRequestFor(agent, sock, {
+    op: "command",
+    name: cmd.name,
+    ...cmd.instructions !== void 0 ? { instructions: cmd.instructions } : {},
+    ...force ? { force: true } : {}
+  });
+  if (!reply.ok) {
+    if (reply.error === "busy") {
+      throw new AgentBusyError(agent.name, agent.workstreamName, `/${cmd.name}`);
+    }
+    throw new Error(`pi refused /${cmd.name}: ${reply.error}`);
+  }
+  return {
+    transport: "ctl",
+    command: cmd.name,
+    ...reply.state !== void 0 ? { state: reply.state } : {}
+  };
+}
 
 // src/agent-state.ts
 var CTL_STATE_PROBE_MS = 1e3;
@@ -8948,6 +8960,15 @@ function murmurDoctorCheck(agentStateSource, opts = {}) {
   };
 }
 var RELINK = "run mu link pi";
+function extFeatures(env) {
+  const features = [
+    ["mu_delegate", "MU_DELEGATE"],
+    ["nudge", "MU_NUDGE"]
+  ];
+  const on = ["ctl", ...features.filter(([, v]) => env[v] !== "0").map(([f]) => f)];
+  const off = features.filter(([, v]) => env[v] === "0").map(([f, v]) => `${f} disabled by ${v}=0`);
+  return `(${on.join(", ")}${off.length ? `; ${off.join("; ")}` : ""})`;
+}
 function ctlExtensionDoctorCheck(opts) {
   const { extension } = inspectLinks(opts);
   switch (extension.state) {
@@ -8955,7 +8976,7 @@ function ctlExtensionDoctorCheck(opts) {
       return {
         name: "mu ext",
         status: "ok",
-        detail: process.env.MU_DELEGATE === "0" ? "(ctl; mu_delegate disabled by MU_DELEGATE=0)" : "(ctl, mu_delegate)"
+        detail: extFeatures(process.env)
       };
     case "stale-copy":
       return { name: "mu ext", status: "warn", detail: `stale copy: ${RELINK}` };
@@ -10919,6 +10940,7 @@ export {
   AgentFreshNeedsCtlError,
   AgentNotFoundError,
   AgentNotInWorkstreamError,
+  AgentSlashCommandUnsupportedError,
   AgentSpawnCliNotFoundError,
   AgentSpawnStartupError,
   CAPTURE_TRIGGER_DDL,