@mu-crew/mu 3.3.0 → 3.4.0

package/README.md

@@ -20,9 +20,9 @@ in-progress, and blocked tasks, the log tail, workspaces, and doctor.*
   socket inside each agent, so send, state, wait, and abort are exact,
   locally and over ssh. The pane stays pi's normal TUI.
 
-mu persists state and coordinates handoffs. It does not choose models,
-run your tests, or pass messages between agents. Every read path has
-`--json`, and every change goes through a typed CLI verb.
+mu persists state and coordinates handoffs. Every read path has
+`--json`, and every change goes through a typed CLI verb. See
+[What mu is not](#what-mu-is-not).
 
 ## Install
 
@@ -71,24 +71,6 @@ For one helper, ask pi to delegate (`mu_delegate` ships with `mu link
 pi`), or spawn into the reserved `scratch` workstream:
 `mu agent spawn scout-1 -w scratch`.
 
-## mu delegates vs hidden subagents
-
-Claude Code, Codex, and pi-subagents delegate to a hidden child process
-and return only its result. A mu delegate is an ordinary agent in a
-pane.
-
-|                         | Hidden subagent          | mu delegate |
-| ----------------------- | ------------------------ | ----------- |
-| Visibility              | none while it runs       | a pane; attach and watch |
-| Steer mid-run           | no                       | `mu agent send`; stop with `mu agent abort` |
-| Keep talking after it answers | no                 | yes, with `keep: true` |
-| Transcript              | collapses into a result  | a normal pi session log |
-| If the work grows       | re-brief a new agent     | same task DAG and workspaces |
-| Cost                    | light                    | one pane and one pi process |
-
-For many tiny calls, a hidden subagent is lighter. mu bets that seeing
-and steering agent work is worth a pane.
-
 ## Ultrathink, the mu way
 
 Long agent runs fail in two ways: the agent stops at 35 of 50 items and
@@ -98,19 +80,28 @@ agents, and have other agents try to refute each result before it
 counts. Claude Code's ultracode does this with a hidden script. mu does
 it in the open:
 
-- **The plan is the DAG.** Every unit, every review, and every round
+- **The plan is the DAG.** Every unit, review gate, finding and round
   is a task before an agent spawns. `mu state` shows 35 of 50 done, so
   nobody can declare victory early.
-- **Reviews are tasks.** A `review_x` task is blocked by `x` and run by
-  a fresh agent, ideally on another model, against criteria written
-  up front. A rejection adds `fix_x` and a second review to the DAG
-  instead of rewriting history.
+- **Findings are tasks.** A reviewer records each problem as a task in
+  triage ([findings](skills/mu/recipes/findings.md)), and it blocks the
+  review until someone accepts it as work or closes it rejected or
+  duplicate. The graph holds the whole review.
+- **Checks are calls.** Refuters, claim checkers and judges are
+  [delegate calls](skills/mu/recipes/tasks-or-calls.md): fresh agents,
+  ideally on another model, whose verdicts land on the task they
+  judged. A 50-unit run adds about 50 units, 50 review gates and the
+  findings that survive, not a task per check.
 - **Every agent is a pane.** Attach to any worker, reviewer, or judge
   mid-run and steer it.
 - **Nothing lives only in a context window.** Verdicts, evidence, and
   stop rules are task notes. The run survives compaction, crashes, and
   a new orchestrator.
 
+Not every review needs a record. Reviewing someone's PR or a doc runs
+as delegates only: findings come back in their answers, and nothing
+lands in the ops log.
+
 Ask your orchestrator to *ultrathink* a job, and it follows
 [skills/mu/recipes/ultrathink.md](skills/mu/recipes/ultrathink.md).
 That recipe composes smaller ones you can also use on their own:
@@ -118,23 +109,46 @@ That recipe composes smaller ones you can also use on their own:
 | Recipe | Shape |
 | ------ | ----- |
 | [fan-out](skills/mu/recipes/fan-out.md) | one task per unit, merged as each closes |
-| [adversarial-review](skills/mu/recipes/adversarial-review.md) | a fresh agent tries to reject each unit before it ships |
-| [refute](skills/mu/recipes/refute.md) | finders, then one refuter per finding, then a report |
+| [adversarial-review](skills/mu/recipes/adversarial-review.md) | a review gate per unit: a fresh agent tries to reject it before it ships |
+| [refute](skills/mu/recipes/refute.md) | finders record findings, one refuter call per finding, report from the graph |
 | [hypothesis-panel](skills/mu/recipes/hypothesis-panel.md) | independent theories from separate evidence, each attacked |
 | [tournament](skills/mu/recipes/tournament.md) | competing attempts, judged in pairs |
 | [loop-until-done](skills/mu/recipes/loop-until-done.md) | rounds until a stop rule written up front holds |
-| [triage](skills/mu/recipes/triage.md) | quarantined readers classify, a trusted actor acts |
+| [backlog-triage](skills/mu/recipes/backlog-triage.md) | quarantined readers classify, a trusted actor acts |
 | [deep-research](skills/mu/recipes/deep-research.md) | searchers by angle, one checker per claim, a cited report |
-| [review-panel](skills/mu/recipes/review-panel.md) | one reviewer per angle on a diff, refuted, then fixed or reported |
+| [review-panel](skills/mu/recipes/review-panel.md) | one reviewer per angle on a diff; delegates by default, tasks when fixes follow |
 | [rules-audit](skills/mu/recipes/rules-audit.md) | one checker per AGENTS.md rule plus a skeptic; or mine repeated corrections into new rules |
 
 In pi, `mu link pi` adds them as commands: `/ultrathink <job>`,
 `/mu-research <question>`, `/mu-review [target]`, `/mu-refute <scope>`,
-`/mu-tournament <task>`, and `/mu-rules-audit [check <target> | mine]`.
+`/mu-tournament <task>`, `/mu-rules-audit [check <target> | mine]`,
+`/mu-debug <symptom>`, `/mu-sweep <change>`, and `/mu-until <stop rule>`.
 
 All recipes, including the orchestrator loop and remote workers, are
 in [skills/mu/recipes/](skills/mu/recipes/).
 
+## What mu is not
+
+- **Not a hidden subagent.** Every agent, including a one-off
+  `mu_delegate` helper, is an ordinary agent in a pane: attach, steer,
+  abort, or keep talking to it. That costs a pane and a pi process per
+  agent; for many tiny calls a hidden subagent is lighter. See
+  [the comparison](docs/guide/delegate.md#delegates-vs-hidden-subagents).
+- **Not a workflow engine.** No DSL, no hidden plan, no script runner.
+  The plan is the task DAG; recipes are instructions an agent follows,
+  and every step is a CLI verb.
+- **Not a model router.** mu does not pick models, thinking levels, or
+  tools. Pass them in the spawn command (`--cli pi_big`).
+- **Not a chat bus.** Agents coordinate through task notes, claims, and
+  the ops log, not messages to each other.
+- **Not a daemon or a service.** No background process, config file, web
+  UI, or RPC. State is one SQLite file; sync rides on ordinary commands.
+- **Not a test runner or a judge.** `--evidence` records what an agent
+  observed; checking it is the orchestrator's job, and the recipes say how.
+
+The full list, with reasons: [VISION § What it is not](docs/VISION.md#what-it-is-not)
+and [ROADMAP § Anti-feature pledges](docs/ROADMAP.md#anti-feature-pledges).
+
 ## Documentation
 
 - [Getting started](docs/guide/getting-started.md): the first

package/dist/cli.js

@@ -393,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"]
     };
@@ -607,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
@@ -5850,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";
@@ -6198,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`);
@@ -6760,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(
@@ -7049,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,
@@ -7191,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();
@@ -10083,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),
@@ -10156,6 +10218,8 @@ function minimalSnapshot(workstream) {
     blocked: [],
     recentClosed: [],
     parkedCount: 0,
+    triage: [],
+    taskCount: 0,
     allTasks: [],
     workspaces: [],
     workspaceOrphans: [],
@@ -11324,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":
@@ -11344,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":
@@ -16537,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 "..."`;
@@ -17596,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]),
@@ -18769,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,
@@ -18793,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>)`
     }
@@ -18916,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}` }]);
@@ -19040,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);
@@ -19060,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;
   }
@@ -19638,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`
@@ -19771,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);
@@ -19849,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)();
   });
@@ -19954,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)();
@@ -19978,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) {
@@ -21395,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`.
@@ -23020,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),
@@ -23092,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("");
@@ -23124,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));
@@ -23131,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("");
@@ -23736,6 +23890,7 @@ function wireWorkspaceCommands(program) {
 }
 
 // src/cli/workstream.ts
+import { basename as basename2 } from "path";
 init_mux2();
 init_output();
 init_workstream();
@@ -23764,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 }) },
     {
@@ -23781,6 +23937,7 @@ async function cmdInit(db, name, opts = {}) {
       muxSessionAlreadyExisted: sessionAlready,
       dbRowAlreadyExisted: !dbCreated,
       muWindowRepaired,
+      ...nameHint && created ? { hint: nameHint } : {},
       nextSteps: nextSteps3
     });
     return;
@@ -23796,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);
@@ -24053,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)();
   });