@mu-crew/mu 3.2.1 → 3.4.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;
 }
@@ -358,7 +359,7 @@ function isTaskStatus(s) {
 }
 var TASK_STATUS_LIST = TASK_STATUSES.join(" | ");
 var TASK_SUBSTATES = {
-  OPEN: ["todo", "parked"],
+  OPEN: ["todo", "parked", "triage"],
   IN_PROGRESS: ["active"],
   CLOSED: ["done", "rejected", "wontfix", "duplicate", "superseded"]
 };
@@ -589,7 +590,7 @@ CREATE VIEW ready AS
   SELECT t.*
     FROM tasks t
    WHERE t.status = 'OPEN'
-     AND t.substate <> 'parked'
+     AND t.substate NOT IN ('parked', 'triage')
      AND NOT EXISTS (
        SELECT 1
          FROM task_edges e
@@ -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++) {
@@ -4590,6 +4560,30 @@ var TaskParkStateError = class extends Error {
     ];
   }
 };
+var TaskInTriageError = class extends Error {
+  constructor(taskId, workstream) {
+    super(`task ${taskId} is in triage (OPEN/triage); accept it or claim with --force`);
+    this.taskId = taskId;
+    this.workstream = workstream;
+  }
+  taskId;
+  workstream;
+  name = "TaskInTriageError";
+  errorNextSteps() {
+    const ws = this.workstream;
+    return [
+      {
+        intent: "Accept it as work, then claim",
+        command: `mu task accept ${this.taskId} -w ${ws}`
+      },
+      {
+        intent: "Decline it",
+        command: `mu task close ${this.taskId} --as rejected --why "<reason>" -w ${ws}`
+      },
+      { intent: "Claim it anyway", command: `mu task claim ${this.taskId} --force -w ${ws}` }
+    ];
+  }
+};
 var TaskParkedError = class extends Error {
   constructor(taskId, workstream) {
     super(`task ${taskId} is parked (OPEN/parked); unpark it or claim with --force`);
@@ -5045,8 +5039,17 @@ function addTaskImpl(db, opts) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const insertResult = db.prepare(
       `INSERT INTO tasks (workstream_id, local_id, title, status, substate, impact, effort_days, created_at, updated_at)
-         VALUES (?, ?, ?, 'OPEN', 'todo', ?, ?, ?, ?)`
-    ).run(wsId, opts.localId, opts.title, opts.impact, opts.effortDays, now, now);
+         VALUES (?, ?, ?, 'OPEN', ?, ?, ?, ?, ?)`
+    ).run(
+      wsId,
+      opts.localId,
+      opts.title,
+      opts.triage === true ? "triage" : "todo",
+      opts.impact,
+      opts.effortDays,
+      now,
+      now
+    );
     const newTaskId = Number(insertResult.lastInsertRowid);
     if (opts.blockedBy && opts.blockedBy.length > 0) {
       const blockerLookupSameWs = db.prepare(
@@ -5321,6 +5324,28 @@ function parkTask(db, localId, opts) {
     })()
   );
 }
+function acceptTask(db, localId, opts) {
+  return withOpContext(
+    db,
+    { intent: "task.accept", group: "new" },
+    () => db.transaction(() => {
+      const before = getTask(db, localId, opts.workstream);
+      if (!before) throw new TaskNotFoundError(localId);
+      if (before.status !== "OPEN" || before.substate !== "triage") {
+        return {
+          previousStatus: before.status,
+          status: before.status,
+          previousSubstate: before.substate,
+          substate: before.substate,
+          changed: false
+        };
+      }
+      const r = setTaskStatus(db, localId, "OPEN", { workstream: opts.workstream });
+      recordEvidenceNote(db, localId, before.workstreamName, "ACCEPT", opts);
+      return r;
+    })()
+  );
+}
 function unparkTask(db, localId, opts) {
   return withOpContext(
     db,
@@ -5451,6 +5476,9 @@ function assertNotParked(task, opts) {
   if (task.status === "OPEN" && task.substate === "parked" && opts.force !== true) {
     throw new TaskParkedError(task.name, task.workstreamName);
   }
+  if (task.status === "OPEN" && task.substate === "triage" && opts.force !== true) {
+    throw new TaskInTriageError(task.name, task.workstreamName);
+  }
 }
 async function resolveActorIdentity() {
   const worker = await resolveWorkerIdentity();
@@ -6485,7 +6513,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 +6653,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 +6668,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 +7090,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 +7143,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 +7187,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 +7217,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 +9018,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 +9034,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}` };
@@ -10001,6 +10080,10 @@ async function loadWorkstreamSnapshotFast(db, workstream, opts = {}) {
     blocked: listBlocked(db, workstream),
     recentClosed: listRecentClosed(db, workstream),
     parkedCount: listTasks(db, workstream, { status: "OPEN", substate: "parked" }).length,
+    triage: listTasks(db, workstream, { status: "OPEN", substate: "triage" }),
+    taskCount: db.prepare(
+      "SELECT count(*) AS n FROM tasks t JOIN workstreams w ON w.id = t.workstream_id WHERE w.name = ?"
+    ).get(workstream).n,
     allTasks: opts.withAllTasks === true ? listTasks(db, workstream) : [],
     workspaces: listWorkspaces2(db, workstream),
     workspaceOrphans: listWorkspaceOrphans(db, workstream),
@@ -10074,6 +10157,8 @@ function minimalSnapshot(workstream) {
     blocked: [],
     recentClosed: [],
     parkedCount: 0,
+    triage: [],
+    taskCount: 0,
     allTasks: [],
     workspaces: [],
     workspaceOrphans: [],
@@ -10919,6 +11004,7 @@ export {
   AgentFreshNeedsCtlError,
   AgentNotFoundError,
   AgentNotInWorkstreamError,
+  AgentSlashCommandUnsupportedError,
   AgentSpawnCliNotFoundError,
   AgentSpawnStartupError,
   CAPTURE_TRIGGER_DDL,
@@ -10969,6 +11055,7 @@ export {
   TASK_SUBSTATE_ROWS,
   TaskAlreadyOwnedError,
   TaskExistsError,
+  TaskInTriageError,
   TaskNotFoundError,
   TaskNotInWorkstreamError,
   TaskParkStateError,
@@ -10985,6 +11072,7 @@ export {
   WorkstreamExistsError,
   WorkstreamNameInvalidError,
   abortAgent,
+  acceptTask,
   activeMux,
   addBlockEdge,
   addNote,