@mu-crew/mu 3.2.1 → 3.4.0

package/dist/cli.js

@@ -14,18 +14,20 @@ function encode(msg) {
   return `${JSON.stringify(msg)}
 `;
 }
-var CTL_PROTOCOL_VERSION, CTL_OPS, UNKNOWN_OP_PREFIX, LineDecoder;
+var CTL_PROTOCOL_VERSION, CTL_COMMANDS, CTL_OPS, UNKNOWN_OP_PREFIX, LineDecoder;
 var init_protocol = __esm({
   "src/ctl/protocol.ts"() {
     "use strict";
     CTL_PROTOCOL_VERSION = 1;
+    CTL_COMMANDS = ["new", "reload", "compact"];
     CTL_OPS = [
       "hello",
       "status",
       "send",
       "wait",
       "abort",
-      "fresh"
+      "fresh",
+      "command"
     ];
     UNKNOWN_OP_PREFIX = "unknown op: ";
     LineDecoder = class {
@@ -44,7 +46,7 @@ var init_protocol = __esm({
 import { createConnection } from "net";
 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;
 }
@@ -391,7 +393,7 @@ var init_status = __esm({
     TASK_STATUSES = ["OPEN", "IN_PROGRESS", "CLOSED"];
     TASK_STATUS_LIST = TASK_STATUSES.join(" | ");
     TASK_SUBSTATES = {
-      OPEN: ["todo", "parked"],
+      OPEN: ["todo", "parked", "triage"],
       IN_PROGRESS: ["active"],
       CLOSED: ["done", "rejected", "wontfix", "duplicate", "superseded"]
     };
@@ -605,7 +607,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
@@ -1289,27 +1291,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(text2) {
   const firstLine = (text2.split("\n")[0] ?? "").trim();
   return firstLine.slice(0, 24);
@@ -1337,7 +1318,6 @@ async function sendToPane(paneId, text2, opts = {}) {
   assertValidPaneId(paneId);
   const readinessMs = opts.readinessMs ?? defaultSendReadinessMs();
   const quiesced = await awaitPaneQuiescence(paneId, readinessMs);
-  const newSessionBaseline = readinessMs > 0 && text2.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(
@@ -1360,15 +1340,6 @@ async function sendToPane(paneId, text2, 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(text2);
   if (probe.length === 0) return;
   for (let attempt = 0; attempt <= SUBMIT_RETRIES; attempt++) {
@@ -4401,7 +4372,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 });
     }
@@ -4510,7 +4481,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);
@@ -4525,30 +4496,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;
-}
-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();
@@ -4594,11 +4541,10 @@ async function firstPaneInWindow(mux, session, windowId) {
   }
   return pane.paneId;
 }
-var AGENT_NAME_CONVENTION_RE, execFileP, activeCommandResolver, CTL_POLL_INTERVAL_MS, STARTUP_ERROR_PATTERNS, STARTUP_ERROR_TAIL_LINES, READINESS_POLL_INTERVAL_MS;
+var AGENT_NAME_CONVENTION_RE, execFileP, activeCommandResolver, CTL_POLL_INTERVAL_MS, STARTUP_ERROR_PATTERNS, STARTUP_ERROR_TAIL_LINES;
 var init_spawn = __esm({
   "src/agents/spawn.ts"() {
     "use strict";
-    init_agent_state();
     init_agents();
     init_client();
     init_path();
@@ -4644,12 +4590,11 @@ var init_spawn = __esm({
       /^(?:.*: )?(?:command not found|No such file or directory)(?::\s*\S+)?$/i
     ];
     STARTUP_ERROR_TAIL_LINES = 30;
-    READINESS_POLL_INTERVAL_MS = 250;
   }
 });
 
 // src/agents/errors.ts
-var AgentSpawnCliNotFoundError, AgentExistsError, AgentNotFoundError, AgentNotInWorkstreamError, AgentDiedOnSpawnError, AgentSpawnStartupError, WorkspacePreservedError, AgentCtlUnreachableError, AgentAbortNeedsCtlError, AgentAbortTimeoutError, AgentFreshNeedsCtlError, AgentExtensionOutdatedError, AgentBusyError;
+var AgentSpawnCliNotFoundError, AgentExistsError, AgentNotFoundError, AgentNotInWorkstreamError, AgentDiedOnSpawnError, AgentSpawnStartupError, WorkspacePreservedError, AgentCtlUnreachableError, AgentAbortNeedsCtlError, AgentAbortTimeoutError, AgentFreshNeedsCtlError, AgentExtensionOutdatedError, AgentBusyError, AgentSlashCommandUnsupportedError;
 var init_errors = __esm({
   "src/agents/errors.ts"() {
     "use strict";
@@ -5029,23 +4974,47 @@ ${scrollback.trim()}
       }
     };
     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 }
+        ];
+      }
+    };
+    AgentSlashCommandUnsupportedError = class extends Error {
+      constructor(agentName, workstream, text2, supported) {
+        super(
+          `agent ${agentName} runs pi: over the control socket mu runs only ${supported.join(", ")}; ${JSON.stringify(text2.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 = text2;
+        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}`
           }
         ];
       }
@@ -5062,10 +5031,21 @@ function agentCtlSocket(db, agent) {
 function expectsCtl(agent, sock = ctlSocketPath(agent.workstreamName, agent.name)) {
   return speaksMuCtl(agent.cli, resolveCliCommand(agent.cli)) || existsSync7(sock);
 }
-function chooseTransport(agent, text2, sock) {
-  if (text2.startsWith("/")) return "mux";
+function chooseTransport(agent, sock) {
   return expectsCtl(agent, sock) ? "ctl" : "mux";
 }
+function parseSessionCommand(text2) {
+  const t = text2.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(text2) {
+  return /^\/[A-Za-z][\w:-]*(?:\s|$)/.test(text2.trimStart());
+}
 async function extensionOutdated(agent, sock, e) {
   let extVersion;
   try {
@@ -5094,11 +5074,23 @@ async function sendViaTransport(agent, text2, 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, text2, sock);
+  const transport = opts.fresh ? "ctl" : opts.via ?? chooseTransport(agent, sock);
   if (transport === "mux") {
     await (await activeMux()).sendToPane(agent.paneId, text2, opts);
     return { transport };
   }
+  if (!opts.fresh) {
+    const cmd = parseSessionCommand(text2);
+    if (cmd) return runSessionCommand(agent, sock, cmd, opts.force === true);
+    if (isSlashCommand(text2)) {
+      throw new AgentSlashCommandUnsupportedError(
+        agent.name,
+        agent.workstreamName,
+        text2,
+        CTL_SLASH_COMMANDS
+      );
+    }
+  }
   const reply = await ctlRequestFor(
     agent,
     sock,
@@ -5112,14 +5104,36 @@ async function sendViaTransport(agent, text2, 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 } : {}
+  };
+}
+var CTL_SLASH_COMMANDS;
 var init_transport = __esm({
   "src/agents/transport.ts"() {
     "use strict";
     init_client();
     init_path();
+    init_protocol();
     init_mux2();
     init_errors();
     init_spawn();
+    CTL_SLASH_COMMANDS = CTL_COMMANDS.map((n) => `/${n}`);
   }
 });
 
@@ -5836,7 +5850,7 @@ var init_id = __esm({
 });
 
 // src/tasks/errors.ts
-var TaskNotFoundError, TaskIdInvalidError, TaskExistsError, TaskNotInWorkstreamError, TaskAlreadyOwnedError, ClaimerNotRegisteredError, TaskClaimStaleWorkspaceError, CycleError, ReaperDetectedDuringWaitError, StallDetectedDuringWaitError, CrossWorkstreamEdgeError, SubstateReasonRequiredError, TaskParkStateError, TaskParkedError, InvalidSubstateError;
+var TaskNotFoundError, TaskIdInvalidError, TaskExistsError, TaskNotInWorkstreamError, TaskAlreadyOwnedError, ClaimerNotRegisteredError, TaskClaimStaleWorkspaceError, CycleError, ReaperDetectedDuringWaitError, StallDetectedDuringWaitError, CrossWorkstreamEdgeError, SubstateReasonRequiredError, TaskParkStateError, TaskInTriageError, TaskParkedError, InvalidSubstateError;
 var init_errors2 = __esm({
   "src/tasks/errors.ts"() {
     "use strict";
@@ -6184,6 +6198,30 @@ var init_errors2 = __esm({
         ];
       }
     };
+    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}` }
+        ];
+      }
+    };
     TaskParkedError = class extends Error {
       constructor(taskId, workstream) {
         super(`task ${taskId} is parked (OPEN/parked); unpark it or claim with --force`);
@@ -6746,8 +6784,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(
@@ -7035,6 +7082,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,
@@ -7177,6 +7246,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();
@@ -9597,6 +9669,15 @@ function murmurDoctorCheck(agentStateSource, opts = {}) {
     detail: version === null ? "agent state from murmur" : `agent state from murmur ${version}`
   };
 }
+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) {
@@ -9604,7 +9685,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}` };
@@ -10060,6 +10141,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),
@@ -10133,6 +10218,8 @@ function minimalSnapshot(workstream) {
     blocked: [],
     recentClosed: [],
     parkedCount: 0,
+    triage: [],
+    taskCount: 0,
     allTasks: [],
     workspaces: [],
     workspaceOrphans: [],
@@ -11301,7 +11388,7 @@ function colorPair(pair) {
   const text2 = formatPair(pair);
   switch (pair.status) {
     case "OPEN":
-      return pair.substate === "parked" ? pc.dim(text2) : pc.cyan(text2);
+      return pair.substate === "parked" || pair.substate === "triage" ? pc.dim(text2) : pc.cyan(text2);
     case "IN_PROGRESS":
       return pc.yellow(text2);
     case "CLOSED":
@@ -11321,7 +11408,7 @@ function colorStatus(status) {
 function inkColorForPair(pair) {
   switch (pair.status) {
     case "OPEN":
-      return pair.substate === "parked" ? "gray" : "cyan";
+      return pair.substate === "parked" || pair.substate === "triage" ? "gray" : "cyan";
     case "IN_PROGRESS":
       return "yellow";
     case "CLOSED":
@@ -16514,6 +16601,7 @@ function yankCommandForTask2(t, ws) {
   switch (t.status) {
     case "OPEN":
       if (t.substate === "parked") return `mu task unpark ${t.name} -w ${ws}`;
+      if (t.substate === "triage") return `mu task accept ${t.name} -w ${ws}`;
       return t.ownerName === null ? `mu task claim ${t.name} -w ${ws}` : `mu task release ${t.name} -w ${ws}`;
     case "IN_PROGRESS":
       return `mu task close ${t.name} -w ${ws} --evidence "..."`;
@@ -17573,6 +17661,7 @@ function snapshotKey(s) {
     blocked: s.blocked.map(taskKey2),
     recentClosed: s.recentClosed.map(taskKey2),
     parkedCount: s.parkedCount,
+    triage: s.triage.map(taskKey2),
     allTasks: s.allTasks.map(taskKey2),
     commitsBackend: s.commitsBackend ?? null,
     recentCommits: s.recentCommits.map((c) => [c.sha, c.subject, c.author, c.relTime]),
@@ -18746,7 +18835,8 @@ async function cmdTaskAdd(db, localId, opts) {
       title: opts.title,
       impact: opts.impact,
       effortDays: opts.effortDays,
-      ...hasBlockers ? { blockedBy } : {}
+      ...hasBlockers ? { blockedBy } : {},
+      ...opts.triage === true ? { triage: true } : {}
     });
     const createdNote = opts.note !== void 0 ? addNote(db, createdTask.name, unescapeNoteText(opts.note), {
       author: initialNoteAuthor,
@@ -18770,7 +18860,7 @@ async function cmdTaskAdd(db, localId, opts) {
       intent: "Add a blocker",
       command: `mu task block ${task.name} --by <other-id> -w ${workstream}`
     },
-    {
+    opts.triage === true ? { intent: "Accept it as work", command: `mu task accept ${task.name} -w ${workstream}` } : {
       intent: "Claim and start",
       command: `mu task claim ${task.name} -w ${workstream} --self  (or --for <worker>)`
     }
@@ -18893,6 +18983,12 @@ async function cmdTaskShow(db, rawId, opts = {}) {
   if (task.substate === "parked") {
     console.log("");
     printNextSteps([{ intent: "Return it to next", command: `mu task unpark ${ref}` }]);
+  } else if (task.substate === "triage") {
+    console.log("");
+    printNextSteps([
+      { intent: "Accept it as work", command: `mu task accept ${ref}` },
+      { intent: "Decline it", command: `mu task close ${ref} --as rejected --why "<reason>"` }
+    ]);
   } else if (task.status === "CLOSED" && task.substate !== "done") {
     console.log("");
     printNextSteps([{ intent: "Reopen it", command: `mu task open ${ref}` }]);
@@ -19017,6 +19113,17 @@ async function cmdTaskList(db, opts) {
   const basis = relTimeBasisForSort(sortKey);
   if (basis !== null) tableOpts.relTimeBasis = basis;
   console.log(formatTaskListTable(tasks, tableOpts));
+  const first = tasks.find((t) => t.status === "OPEN" && t.substate === "triage");
+  if (first !== void 0) {
+    printNextSteps([
+      { intent: "Accept as work", command: `mu task accept ${first.name} -w ${workstream}` },
+      {
+        intent: "Decline",
+        command: `mu task close ${first.name} --as rejected|duplicate --why "<reason>" -w ${workstream}`
+      },
+      { intent: "Read the evidence", command: `mu task notes ${first.name} -w ${workstream}` }
+    ]);
+  }
 }
 async function cmdTaskNext(db, opts) {
   const workstream = await resolveWorkstream(opts.workstream);
@@ -19037,16 +19144,26 @@ async function cmdTaskNext(db, opts) {
   }
   if (tasks.length === 0) {
     const parked = listTasks(db, workstream, { substate: "parked" }).length;
-    if (parked === 0) {
+    const triage = listTasks(db, workstream, { substate: "triage" }).length;
+    if (parked === 0 && triage === 0) {
       console.log(pc.dim("(no ready tasks)"));
       return;
     }
-    console.log(pc.dim(`(no ready tasks; ${parked} parked)`));
+    const held = [parked > 0 ? `${parked} parked` : "", triage > 0 ? `${triage} in triage` : ""].filter(Boolean).join(", ");
+    console.log(pc.dim(`(no ready tasks; ${held})`));
     printNextSteps([
-      {
-        intent: "List parked tasks",
-        command: `mu task list --substate parked -w ${workstream}`
-      }
+      ...triage > 0 ? [
+        {
+          intent: "Triage findings",
+          command: `mu task list --substate triage -w ${workstream}`
+        }
+      ] : [],
+      ...parked > 0 ? [
+        {
+          intent: "List parked tasks",
+          command: `mu task list --substate parked -w ${workstream}`
+        }
+      ] : []
     ]);
     return;
   }
@@ -19615,7 +19732,14 @@ async function cmdTaskClose(db, rawId, opts = {}) {
   const taskRow = getTask(db, localId, ws);
   const r = closeTask(db, localId, sdkOpts);
   if ("skipped" in r) {
+    const inTriage = r.blockingIds.filter((id) => getTask(db, id, ws)?.substate === "triage");
     const blockingNextSteps = [
+      ...inTriage.length > 0 ? [
+        {
+          intent: `Triage ${inTriage.length} blocking finding(s) (accept, or close --as rejected|duplicate)`,
+          command: `mu task list --substate triage -w ${ws}`
+        }
+      ] : [],
       {
         intent: "Watch the remaining blockers (returns when one closes)",
         command: `mu task wait ${r.blockingIds.join(" ")} -w ${ws} --first --any --on-stall exit`
@@ -19748,6 +19872,32 @@ async function cmdTaskPark(db, rawId, opts) {
   }
   printNextSteps(nextSteps3);
 }
+async function cmdTaskAccept(db, rawId, opts = {}) {
+  const { name: localId } = await resolveEntityRef(db, rawId, opts, "task");
+  assertTaskInWorkstream(db, localId, opts.workstream);
+  const ws = await resolveWorkstream(opts.workstream);
+  const sdkOpts = { workstream: ws };
+  if (opts.evidence !== void 0) sdkOpts.evidence = opts.evidence;
+  const r = acceptTask(db, localId, sdkOpts);
+  const nextSteps3 = [
+    {
+      intent: "Claim it",
+      command: `mu task claim ${localId} -w ${ws}  (--self / --for <worker>)`
+    },
+    { intent: "Triage the next one", command: `mu task list --substate triage -w ${ws}` }
+  ];
+  if (opts.json) {
+    emitJson({ taskName: localId, ...r, nextSteps: nextSteps3 });
+    return;
+  }
+  if (!r.changed) {
+    const pair = formatPair({ status: r.status, substate: r.substate });
+    console.log(pc.dim(`${localId} is ${pair}, not in triage (no-op)`));
+  } else {
+    console.log(`Accepted ${pc.bold(localId)} ${pc.dim(`(${transition(r)})`)}`);
+  }
+  printNextSteps(nextSteps3);
+}
 async function cmdTaskUnpark(db, rawId, opts = {}) {
   const { name: localId } = await resolveEntityRef(db, rawId, opts, "task");
   assertTaskInWorkstream(db, localId, opts.workstream);
@@ -19826,7 +19976,10 @@ function wireTaskCommands(program) {
   ).requiredOption("-t, --title <title>", "task title").requiredOption("-i, --impact <n>", "impact 1..100", parseImpact).requiredOption("-e, --effort-days <days>", "effort in days (>0)", parsePositiveNumber).option(
     "-b, --blocked-by <ids...>",
     "task ids that block this one (repeat or comma-separate; or both)"
-  ).option("--note <text>", "append an initial note after creating the task").option("--note-author <name>", "author label for --note (default: current actor)").option(...WORKSTREAM_OPT).option(...JSON_OPT).action(function(id) {
+  ).option("--note <text>", "append an initial note after creating the task").option("--note-author <name>", "author label for --note (default: current actor)").option(
+    "--triage",
+    "start as OPEN/triage: a proposal (e.g. a review finding) kept out of next/claim until `mu task accept`"
+  ).option(...WORKSTREAM_OPT).option(...JSON_OPT).action(function(id) {
     const opts = this.opts();
     return handle((db) => cmdTaskAdd(db, id, opts), this)();
   });
@@ -19931,6 +20084,12 @@ function wireTaskCommands(program) {
     const opts = this.opts();
     return handle((db) => cmdTaskPark(db, id, opts), this)();
   });
+  task.command("accept <id>").description(
+    "Accept an OPEN/triage task (a proposed finding) as work: OPEN/todo, back in `next`. No-op on any other state. Decline with `close --as rejected|duplicate --why`."
+  ).option(...WORKSTREAM_OPT).option(...EVIDENCE_OPT).option(...JSON_OPT).action(function(id) {
+    const opts = this.opts();
+    return handle((db) => cmdTaskAccept(db, id, opts), this)();
+  });
   task.command("unpark <id>").description("Return a parked task to OPEN (back in `next`). No-op on any other state.").option(...WORKSTREAM_OPT).option(...EVIDENCE_OPT).option(...JSON_OPT).action(function(id) {
     const opts = this.opts();
     return handle((db) => cmdTaskUnpark(db, id, opts), this)();
@@ -19955,7 +20114,7 @@ function wireTaskCommands(program) {
   ).option(
     "--actor <name>",
     "override the actor name used for the log (only valid with --self; defaults to pane title or $USER)"
-  ).option("--force", "claim even when the task is parked (OPEN/parked)").option(
+  ).option("--force", "claim even when the task is parked or in triage (OPEN/parked, OPEN/triage)").option(
     "--strict-staleness",
     "refuse --for dispatch when the target agent's workspace is stale (default: warn and proceed)"
   ).option(...WORKSTREAM_OPT).option(...EVIDENCE_OPT).option(...JSON_OPT).action(function(taskId) {
@@ -20117,7 +20276,9 @@ function parseVia(raw) {
 }
 async function cmdSend(db, rawName, text2, opts = {}) {
   const via = parseVia(opts.via);
-  if (opts.force && !opts.fresh) throw new UsageError("--force only applies with --fresh");
+  if (opts.force && !opts.fresh && parseSessionCommand(text2) === void 0) {
+    throw new UsageError("--force only applies with --fresh or a /new, /reload, /compact");
+  }
   if (opts.fresh && opts.steer) throw new UsageError("--fresh and --steer are mutually exclusive");
   const { name } = await resolveEntityRef(db, rawName, opts, "agent");
   assertAgentInWorkstream(db, name, opts.workstream);
@@ -20127,7 +20288,7 @@ async function cmdSend(db, rawName, text2, opts = {}) {
   });
   let undelivered;
   const agentRow = getAgent(db, name, ws);
-  const plainCtl = agentRow !== void 0 && !opts.fresh && !opts.steer && (via ?? chooseTransport(agentRow, text2, agentCtlSocket(db, agentRow))) === "ctl";
+  const plainCtl = agentRow !== void 0 && !opts.fresh && !opts.steer && parseSessionCommand(text2) === void 0 && (via ?? chooseTransport(agentRow, agentCtlSocket(db, agentRow))) === "ctl";
   const before = plainCtl && agentRow !== void 0 ? await ctlProbe(agentCtlSocket(db, agentRow)) : void 0;
   const sent = await sendToAgent(db, name, text2, {
     workstream: ws,
@@ -20161,6 +20322,7 @@ async function cmdSend(db, rawName, text2, opts = {}) {
       sentBytes: text2.length,
       transport: sent.transport,
       fresh: opts.fresh === true,
+      ...sent.command !== void 0 ? { command: sent.command } : {},
       ...sent.state !== void 0 ? { state: sent.state } : {},
       delivered: undelivered === void 0,
       ...undelivered !== void 0 ? { undelivered: { reason: undelivered.reason, message: undelivered.message } } : {},
@@ -20172,7 +20334,7 @@ async function cmdSend(db, rawName, text2, opts = {}) {
   if (undelivered !== void 0) {
     console.error(pc.yellow(`warning: ${undelivered.message}`));
   } else {
-    const how = sent.transport === "mux" ? "via mux paste" : opts.fresh ? "via ctl, fresh session" : `via ctl, pi ${sent.state ?? "?"}`;
+    const how = sent.transport === "mux" ? "via mux paste" : opts.fresh ? "via ctl, fresh session" : sent.command !== void 0 ? `via ctl, pi ran /${sent.command}` : `via ctl, pi ${sent.state ?? "?"}`;
     console.log(pc.dim(`sent ${text2.length} bytes to ${name} (${how})`));
   }
   printNextSteps(nextSteps3);
@@ -20613,14 +20775,17 @@ function wireAgentCommands(program) {
     return handle((db) => cmdSpawn(db, name, opts), this)();
   });
   agent.command("send <name> <text>").description(
-    "Send text to an agent. pi agents: through the control socket (fails loud if it does not answer; no paste fallback). Non-pi CLIs and text starting with '/' (slash commands such as /new): pasted into the pane (atomic on herdr; bracketed-paste on tmux). --fresh (pi only): start a new session and send the text into it as one operation; returns once the prompt's run has started, so an immediate next send cannot be lost. Use it instead of sending '/new' then the prompt"
+    "Send text to an agent. pi agents: through the control socket (fails loud if it does not answer; no paste fallback); '/new', '/reload' and '/compact [instructions]' run inside pi over the socket (refused while busy unless --force), any other slash command is refused (--via mux types it into the pane). Non-pi CLIs: pasted into the pane (atomic on herdr; bracketed-paste on tmux). --fresh (pi only): start a new session and send the text into it as one operation; returns once the prompt's run has started, so an immediate next send cannot be lost. Use it instead of sending '/new' then the prompt"
   ).option(
     "--strict-staleness",
     "refuse send when the target agent's workspace is stale (default: warn and proceed)"
   ).option("--steer", "if pi is busy, interrupt the current run (default: queue as a follow-up)").option("--via <transport>", "force the transport: ctl or mux (mux = paste into the pane)").option(
     "--fresh",
     "pi only: new session + this prompt, one operation (refused with exit 4 while pi is busy)"
-  ).option("--force", "with --fresh: abandon a running turn instead of refusing").option(...WORKSTREAM_OPT).option(...JSON_OPT).action(function(name, text2) {
+  ).option(
+    "--force",
+    "with --fresh or a pi /new, /reload, /compact: abandon a running turn instead of refusing"
+  ).option(...WORKSTREAM_OPT).option(...JSON_OPT).action(function(name, text2) {
     const opts = this.opts();
     return handle((db) => cmdSend(db, name, text2, opts), this)();
   });
@@ -21348,7 +21513,8 @@ var NameAmbiguousError = class extends Error {
 function classifyError(err) {
   if (err instanceof UsageError || // abort on a non-pi agent: the operator picked the wrong verb (kick).
   err instanceof AgentAbortNeedsCtlError || // send --fresh on an agent with no control socket: wrong recipe.
-  err instanceof AgentFreshNeedsCtlError || err instanceof WorkstreamNameInvalidError || err instanceof WorkstreamNameReservedError || // The operator asked the ACTIVE backend for something it cannot do:
+  err instanceof AgentFreshNeedsCtlError || // an unsupported slash command to a pi agent: --via mux is the recipe.
+  err instanceof AgentSlashCommandUnsupportedError || err instanceof WorkstreamNameInvalidError || err instanceof WorkstreamNameReservedError || // The operator asked the ACTIVE backend for something it cannot do:
   // a `--cli` the mux does not recognise as an agent kind, or a
   // `--command` / `MU_<CLI>_COMMAND` override it cannot honour. The
   // substrate is healthy and answered precisely, so this is the usage
@@ -21365,7 +21531,7 @@ function classifyError(err) {
   }
   if (err instanceof NameAmbiguousError || err instanceof AgentExistsError || err instanceof TaskExistsError || err instanceof TaskAlreadyOwnedError || // Substate refusals (ts_4): a missing --why, a park from the wrong
   // phase, a claim on a parked task, a pair outside TASK_SUBSTATES.
-  err instanceof SubstateReasonRequiredError || err instanceof TaskParkStateError || err instanceof TaskParkedError || err instanceof InvalidSubstateError || err instanceof TaskClaimStaleWorkspaceError || err instanceof TaskNotInWorkstreamError || err instanceof AgentNotInWorkstreamError || err instanceof CycleError || err instanceof CrossWorkstreamEdgeError || err instanceof WorkspaceExistsError || err instanceof WorkspacePathNotEmptyError || err instanceof WorkspacePreservedError || err instanceof HomeDirAsProjectRootError || err instanceof WorkspaceVcsRequiredError || err instanceof WorkspaceDirtyError || err instanceof ClaimerNotRegisteredError || err instanceof SchemaTooOldError || err instanceof SchemaTooNewError || err instanceof TaskIdInvalidError || err instanceof WorkstreamExistsError || // Rebuild refuses to overwrite an existing target or to write onto
+  err instanceof SubstateReasonRequiredError || err instanceof TaskParkStateError || err instanceof TaskParkedError || err instanceof TaskInTriageError || err instanceof InvalidSubstateError || err instanceof TaskClaimStaleWorkspaceError || err instanceof TaskNotInWorkstreamError || err instanceof AgentNotInWorkstreamError || err instanceof CycleError || err instanceof CrossWorkstreamEdgeError || err instanceof WorkspaceExistsError || err instanceof WorkspacePathNotEmptyError || err instanceof WorkspacePreservedError || err instanceof HomeDirAsProjectRootError || err instanceof WorkspaceVcsRequiredError || err instanceof WorkspaceDirtyError || err instanceof ClaimerNotRegisteredError || err instanceof SchemaTooOldError || err instanceof SchemaTooNewError || err instanceof TaskIdInvalidError || err instanceof WorkstreamExistsError || // Rebuild refuses to overwrite an existing target or to write onto
   // the source DB: both are name/state collisions, not usage errors.
   err instanceof RebuildTargetExistsError || err instanceof RebuildTargetIsSourceError || // An abbreviated group id matching several groups: the operator must
   // disambiguate. Guessing would be catastrophic for `mu undo`.
@@ -22990,6 +23156,7 @@ function fullJsonShape(d) {
     orphans: d.view.orphans,
     tracks: d.tracks,
     ready: withRoiAll(d.ready),
+    triage: withRoiAll(d.triage),
     inProgress: withRoiAll(d.inProgress),
     blocked: withRoiAll(d.blocked),
     recentClosed: withRoiAll(d.recentClosed),
@@ -23062,6 +23229,7 @@ async function cmdState(db, opts) {
   }
   renderFullMode(perWs);
 }
+var BIG_WORKSTREAM_TASKS = 300;
 function renderFullMode(perWs) {
   perWs.forEach((d, i) => {
     if (i > 0) console.log("");
@@ -23094,6 +23262,15 @@ function renderFullCard(d) {
       );
     }
   }
+  const total = d.taskCount;
+  const open = ready.length + inProgress.length + blocked.length + d.triage.length;
+  if (total >= BIG_WORKSTREAM_TASKS && open * 10 < total) {
+    console.log(
+      pc.dim(
+        `hint: ${total} tasks, ${open} open; start the next effort in a new <project>-<purpose> workstream`
+      )
+    );
+  }
   console.log("");
   console.log(pc.bold(`Tracks (${tracks.length})`));
   console.log(formatTracks(tracks));
@@ -23101,6 +23278,13 @@ function renderFullCard(d) {
   console.log(pc.bold(`Ready (${ready.length})`));
   console.log(ready.length === 0 ? pc.dim("  (none)") : formatTaskListTable(ready));
   console.log("");
+  if (d.triage.length > 0) {
+    console.log(
+      `${pc.bold(`Triage (${d.triage.length})`)} ${pc.dim(`accept: mu task accept <id> -w ${workstreamName} \xB7 decline: mu task close <id> --as rejected|duplicate --why ...`)}`
+    );
+    console.log(formatTaskListTable(d.triage));
+    console.log("");
+  }
   console.log(pc.bold(`In progress (${inProgress.length})`));
   console.log(inProgress.length === 0 ? pc.dim("  (none)") : formatTaskListTable(inProgress));
   console.log("");
@@ -23706,6 +23890,7 @@ function wireWorkspaceCommands(program) {
 }
 
 // src/cli/workstream.ts
+import { basename as basename2 } from "path";
 init_mux2();
 init_output();
 init_workstream();
@@ -23734,6 +23919,7 @@ async function cmdInit(db, name, opts = {}) {
   await mux.enableMuPaneBordersForSession(sessionName).catch(() => {
   });
   const created = !sessionAlready || dbCreated;
+  const nameHint = name.includes("-") ? void 0 : `name workstreams <project>-<purpose> (e.g. ${projectGuess() ?? "repo"}-${name}); one per effort`;
   const nextSteps3 = [
     { intent: "Attach the session", command: mux.attachHint({ session: sessionName }) },
     {
@@ -23751,6 +23937,7 @@ async function cmdInit(db, name, opts = {}) {
       muxSessionAlreadyExisted: sessionAlready,
       dbRowAlreadyExisted: !dbCreated,
       muWindowRepaired,
+      ...nameHint && created ? { hint: nameHint } : {},
       nextSteps: nextSteps3
     });
     return;
@@ -23766,8 +23953,13 @@ async function cmdInit(db, name, opts = {}) {
     return;
   }
   console.log(`Created workstream ${pc.bold(name)} (mux session ${pc.bold(sessionName)})`);
+  if (nameHint && created) console.log(pc.dim(`hint: ${nameHint}`));
   printNextSteps(nextSteps3);
 }
+function projectGuess() {
+  const base = basename2(process.cwd()).toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[^a-z]+/, "").replace(/-+$/, "");
+  return base === "" ? void 0 : base;
+}
 async function cmdWorkstreamList(db, opts = {}) {
   if (opts.tornDown === true) {
     const gone = listTornDownWorkstreams(db);
@@ -24023,8 +24215,12 @@ function withPositionalWorkstream(opts, name) {
   return { ...opts, workstream: name };
 }
 function wireWorkstreamCommands(program) {
-  const workstream = program.command("workstream").description("Workstream-level commands");
-  workstream.command("init <name>").description("Create the workstream's mux session and register it in the DB").option(...JSON_OPT).action(function(name) {
+  const workstream = program.command("workstream").description(
+    "Workstream-level commands. Name them <project>-<purpose> (hail-auth), one per effort; tear down when it ships. Reviews nobody will track belong in scratch delegates, not a workstream."
+  );
+  workstream.command("init <name>").description(
+    "Create the workstream's mux session and register it in the DB. Name it <project>-<purpose>."
+  ).option(...JSON_OPT).action(function(name) {
     const opts = this.opts();
     return handle((db) => cmdInit(db, name, opts), this)();
   });