@mu-crew/mu 3.13.2 → 4.0.0

package/dist/chunk-5HECDBK3.js

@@ -0,0 +1,4482 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
+import {
+  DelegateCallConflictError,
+  DelegateNotFoundError,
+  DelegateStateError,
+  IN_FLIGHT_STATES,
+  TERMINAL_DELEGATE_STATES,
+  ambientFlush,
+  ambientIngest,
+  authorisedReady,
+  autoPermitted,
+  countUnpublishedOps,
+  currentCallers,
+  deliveredOf,
+  endAttempt,
+  finishDelegate,
+  foreignVersionMessage,
+  getAutoConfig,
+  getDelegateCall,
+  listDelegates,
+  listDelegatesOf,
+  liveAgentToOutput,
+  localMachineId,
+  markDelegate,
+  openHumanNeeds,
+  ownSegmentForeignLine,
+  pendingAttempts,
+  pinnedNotes,
+  planAttempt,
+  projectLog,
+  readAttempt,
+  recordHumanNeeded,
+  registerDelegateCall,
+  reserveAttempt,
+  reserveRetry,
+  tallyCalls,
+  verdictTally
+} from "./chunk-GQNHIPJN.js";
+import {
+  AgentLockBusyError,
+  AgentNotFoundError,
+  AgentReplacedError,
+  AgentRestartedError,
+  AgentSendRefusedError,
+  CTL_DEFAULT_TIMEOUT_MS,
+  CtlWriteVetoedError,
+  DEFAULT_SUBSTATE,
+  DELEGATE_TOKEN,
+  NoMultiplexerError,
+  RemoteRecoveryRefusedError,
+  SYNCED_ENTITIES,
+  SpawnAttemptBusyError,
+  SpawnAttemptGuardError,
+  TaskNotFoundError,
+  WorkstreamNotFoundError,
+  activeMux,
+  addNote,
+  agentCtlSocket,
+  agentKey,
+  agentOwed,
+  assertRecoveryProfile,
+  assertRecoveryUnchanged,
+  assertRecoveryUsable,
+  beginWait,
+  checkCaller,
+  checkMessage,
+  closeTask,
+  closedToken,
+  compareHlc,
+  compareStrings,
+  ctlProbe,
+  cursorKey,
+  delegateOutcome,
+  deleteAgent,
+  dropOwnedRefs,
+  emitEvent,
+  endWait,
+  expectsCtl,
+  fenceAgentRef,
+  getAgent,
+  getReceipt,
+  getTask,
+  getTaskNote,
+  getTaskOwner,
+  git,
+  hasDoneMark,
+  isConsumed,
+  isValidTaskId,
+  listBlocked,
+  listInProgress,
+  listReady,
+  listTasks,
+  listTasksByOwner,
+  localPaneAlive,
+  locksDir,
+  logStallOnce,
+  newMsgId,
+  observeAgentStates,
+  openDb,
+  parseHlc,
+  pinnedByOthers,
+  readCursors,
+  readLiveAgents,
+  readWaitRegistration,
+  recordCursors,
+  recordSend,
+  recoveryGone,
+  recoveryHolds,
+  registerOwnedWait,
+  releaseTask,
+  resolveCliCommand,
+  runLeasedTemplate,
+  savedIdentity,
+  say,
+  selectRemoteRecovery,
+  sendViaTransport,
+  setAgentDone,
+  setRecoveryCollectedHead,
+  settledCloseInput,
+  spawnAutoAttempt,
+  spawnForTask,
+  speaksMuCtl,
+  taskIdFor,
+  taskRevision,
+  tryResolveLiveWorkstreamId,
+  watchAgentRun,
+  withAgentLock,
+  withCaptureSuppressed,
+  withFileLock,
+  withHostChannel,
+  withOpContext
+} from "./chunk-S424D5EP.js";
+
+// src/rebuild.ts
+import { existsSync, mkdirSync, rmSync, statSync } from "fs";
+import { dirname } from "path";
+var RebuildTargetExistsError = class extends Error {
+  constructor(path) {
+    super(say("rebuild.target_exists", path));
+    this.path = path;
+    this.name = "RebuildTargetExistsError";
+  }
+  path;
+};
+var RebuildTargetIsSourceError = class extends Error {
+  constructor(path) {
+    super(say("rebuild.target_is_source", path));
+    this.path = path;
+    this.name = "RebuildTargetIsSourceError";
+  }
+  path;
+};
+var UNREBUILDABLE_TABLES = [
+  "agents",
+  "task_auto",
+  "worktrees",
+  "delegate_calls",
+  "wait_cursors",
+  "wait_registrations",
+  // The condition sets behind `mu wait --resume <id>`: a handle is worthless on a rebuilt DB.
+  "wait_resumes",
+  "agent_settles",
+  "host_profiles",
+  "host_channels",
+  "spawn_receipts",
+  // The stall actions a wait took (steer exclusion, release record): no op carries them.
+  "wait_action_receipts",
+  // A remote worker's worktree, kept when its row was deleted: no op carries it.
+  "remote_recovery",
+  // The human task and its reason rebuild from ops; WHO recorded it does
+  // not. Ownership is never inferred from a note author.
+  "human_needs"
+];
+var LOG_ONLY_ENTITIES = /* @__PURE__ */ new Set(["message", "event", "broadcast"]);
+function isProjectable(entity) {
+  if (LOG_ONLY_ENTITIES.has(entity)) return false;
+  return SYNCED_ENTITIES.includes(entity);
+}
+function rebuildInto(source, opts) {
+  const { targetPath } = opts;
+  const sourceFile = source.pragma("database_list").find(
+    (row) => row.name === "main"
+  )?.file;
+  if (sourceFile !== void 0 && sourceFile.length > 0) {
+    const sameFile = sourceFile === targetPath || existsSync(targetPath) && existsSync(sourceFile) && sameInode(sourceFile, targetPath);
+    if (sameFile) throw new RebuildTargetIsSourceError(targetPath);
+  }
+  if (existsSync(targetPath) && opts.force !== true) {
+    throw new RebuildTargetExistsError(targetPath);
+  }
+  mkdirSync(dirname(targetPath), { recursive: true });
+  const snapshot2 = source.transaction(() => {
+    const identity2 = source.prepare(
+      "SELECT machine_id, hostname, created_at, last_wall, last_counter FROM machine_identity WHERE id = 1"
+    ).get();
+    if (!identity2) throw new Error(say("rebuild.no_identity"));
+    const opRows2 = source.prepare(
+      `SELECT hlc, machine_id, group_id, actor, intent, entity, key, op, payload, created_at
+           FROM ops`
+    ).all();
+    opRows2.sort((a, b) => compareHlc(a.hlc, b.hlc));
+    const peerRows2 = source.prepare("SELECT machine_id, last_applied_seq, last_seen_at FROM sync_peers").all();
+    const machineLocalLost2 = [];
+    for (const table of UNREBUILDABLE_TABLES) {
+      const row = source.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get();
+      if (row.n > 0) machineLocalLost2.push({ table, rows: row.n });
+    }
+    return { identity: identity2, opRows: opRows2, peerRows: peerRows2, machineLocalLost: machineLocalLost2 };
+  });
+  const { identity, opRows, peerRows, machineLocalLost } = snapshot2();
+  if (opts.force === true) {
+    for (const suffix of ["", "-wal", "-shm"]) rmSync(`${targetPath}${suffix}`, { force: true });
+  }
+  const target = openDb({ path: targetPath });
+  try {
+    target.prepare(
+      `UPDATE machine_identity
+            SET machine_id = @machineId, hostname = @hostname, created_at = @createdAt,
+                last_wall = @lastWall, last_counter = @lastCounter
+          WHERE id = 1`
+    ).run({
+      machineId: identity.machine_id,
+      hostname: identity.hostname,
+      createdAt: identity.created_at,
+      lastWall: identity.last_wall,
+      lastCounter: identity.last_counter
+    });
+    const insertOp = target.prepare(
+      `INSERT OR IGNORE INTO ops
+         (hlc, machine_id, group_id, actor, intent, entity, key, op, payload, created_at)
+       VALUES (@hlc, @machineId, @groupId, @actor, @intent, @entity, @key, @op, @payload, @createdAt)`
+    );
+    const insertPeer = target.prepare(
+      `INSERT OR REPLACE INTO sync_peers (machine_id, last_applied_seq, last_seen_at)
+       VALUES (@machineId, @lastAppliedSeq, @lastSeenAt)`
+    );
+    const logOnlyByEntity = {};
+    let opsProjected = 0;
+    let opsChangedRows = 0;
+    const replay = target.transaction(() => {
+      withCaptureSuppressed(target, () => {
+        for (const row of opRows) {
+          insertOp.run({
+            hlc: row.hlc,
+            machineId: row.machine_id,
+            groupId: row.group_id,
+            actor: row.actor,
+            intent: row.intent,
+            entity: row.entity,
+            key: row.key,
+            op: row.op,
+            payload: row.payload,
+            createdAt: row.created_at
+          });
+          if (isProjectable(row.entity)) opsProjected += 1;
+          else logOnlyByEntity[row.entity] = (logOnlyByEntity[row.entity] ?? 0) + 1;
+        }
+        advanceClockPast(target, opRows);
+        opsChangedRows = projectLog(target);
+        for (const peer of peerRows) {
+          insertPeer.run({
+            machineId: peer.machine_id,
+            lastAppliedSeq: peer.last_applied_seq,
+            lastSeenAt: peer.last_seen_at
+          });
+        }
+      });
+    });
+    replay.immediate();
+    const rebuiltRows = {};
+    for (const table of ["workstreams", "tasks", "task_edges", "task_notes", "ops"]) {
+      const row = target.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get();
+      rebuiltRows[table] = row.n;
+    }
+    return {
+      targetPath,
+      opsCopied: rebuiltRows.ops ?? 0,
+      opsProjected,
+      opsChangedRows,
+      logOnlyByEntity,
+      rebuiltRows,
+      machineLocalLost,
+      machineId: identity.machine_id
+    };
+  } finally {
+    target.close();
+  }
+}
+function advanceClockPast(target, rows) {
+  let newest;
+  for (const row of rows) {
+    let h;
+    try {
+      h = parseHlc(row.hlc);
+    } catch {
+      continue;
+    }
+    if (!newest || h.wallMs > newest.wallMs || h.wallMs === newest.wallMs && h.counter > newest.counter) {
+      newest = h;
+    }
+  }
+  if (!newest) return;
+  target.prepare(
+    `UPDATE machine_identity SET last_wall = @wall, last_counter = @counter
+        WHERE id = 1 AND (last_wall < @wall OR (last_wall = @wall AND last_counter < @counter))`
+  ).run({ wall: newest.wallMs, counter: newest.counter });
+}
+function sameInode(a, b) {
+  try {
+    const sa = statSync(a);
+    const sb = statSync(b);
+    return sa.ino === sb.ino && sa.dev === sb.dev;
+  } catch {
+    return false;
+  }
+}
+
+// src/drift.ts
+import { mkdtempSync, rmSync as rmSync2 } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var DRIFT_REPORT_CAP = 20;
+function checkCheapDriftInvariant(db) {
+  const started = Date.now();
+  const unexplained = [];
+  const probes = [
+    {
+      table: "workstreams",
+      sql: `SELECT w.name AS key FROM workstreams w
+             WHERE NOT EXISTS (
+               SELECT 1 FROM ops o WHERE o.entity = 'workstream' AND o.key = w.name)`
+    },
+    {
+      table: "tasks",
+      sql: `SELECT w.name || '/' || t.local_id AS key
+              FROM tasks t JOIN workstreams w ON w.id = t.workstream_id
+             WHERE NOT EXISTS (
+               SELECT 1 FROM ops o
+                WHERE o.entity = 'task' AND o.key = w.name || '/' || t.local_id)`
+    },
+    {
+      table: "task_edges",
+      sql: `SELECT wf.name || '/' || f.local_id || '->' || wt.name || '/' || t.local_id AS key
+              FROM task_edges e
+              JOIN tasks f ON f.id = e.from_task_id
+              JOIN tasks t ON t.id = e.to_task_id
+              JOIN workstreams wf ON wf.id = f.workstream_id
+              JOIN workstreams wt ON wt.id = t.workstream_id
+             WHERE NOT EXISTS (
+               SELECT 1 FROM ops o
+                WHERE o.entity = 'edge'
+                  AND o.key = wf.name || '/' || f.local_id || '->' || wt.name || '/' || t.local_id)`
+    },
+    {
+      // Notes are keyed <task-key>#<origin-id> and the origin id is the
+      // AUTHORING machine's surrogate id, which need not match ours (see
+      // src/apply.ts § syncNotes). So match on the task-key PREFIX
+      // rather than the exact key: the question here is "does the log
+      // know about a note on this task at all", not "which note".
+      //
+      // Express the prefix as an indexed half-open range. A correlated
+      // `LIKE task_key || '#%'` made SQLite scan every note op for every
+      // live note (seconds on the dogfood DB); '#'..'$' contains exactly
+      // the strings beginning with `task_key || '#'` because task ids
+      // cannot contain either delimiter.
+      //
+      // The answer is per TASK, so probe each task that has notes once
+      // (2.3k probes, not 10.7k on the dogfood DB), then list the notes
+      // of the tasks that fail. MATERIALIZED stops SQLite flattening the
+      // probe back into a per-note subquery.
+      table: "task_notes",
+      sql: `WITH bare AS MATERIALIZED (
+              SELECT t.id AS task_id, w.name || '/' || t.local_id AS task_key
+                FROM tasks t
+                JOIN workstreams w ON w.id = t.workstream_id
+               WHERE t.id IN (SELECT task_id FROM task_notes)
+                 AND NOT EXISTS (
+                   SELECT 1 FROM ops o
+                    WHERE o.entity = 'note'
+                      AND o.key >= w.name || '/' || t.local_id || '#'
+                      AND o.key <  w.name || '/' || t.local_id || '$'))
+            SELECT b.task_key || '#' || n.id AS key
+              FROM bare b
+              JOIN task_notes n ON n.task_id = b.task_id
+             ORDER BY n.task_id, n.id`
+    }
+  ];
+  for (const probe of probes) {
+    const rows = db.prepare(probe.sql).all();
+    for (const row of rows) unexplained.push({ table: probe.table, key: row.key });
+  }
+  return {
+    clean: unexplained.length === 0,
+    unexplainedRows: unexplained.slice(0, DRIFT_REPORT_CAP),
+    totalUnexplained: unexplained.length,
+    elapsedMs: Date.now() - started
+  };
+}
+var COMPARED = {
+  workstreams: ["created_at", "torn_down_at"],
+  tasks: [
+    "title",
+    "status",
+    "substate",
+    "impact",
+    "effort_days",
+    "scored",
+    "dispatch_host",
+    "kind",
+    "wave",
+    "created_at",
+    "updated_at"
+  ],
+  task_notes: ["author", "content", "created_at", "kind"],
+  task_edges: ["created_at"]
+};
+var SNAPSHOT_SQL = {
+  workstreams: `SELECT w.name AS key, w.created_at, w.torn_down_at
+                  FROM workstreams w`,
+  tasks: `SELECT w.name || '/' || t.local_id AS key,
+                 t.title, t.status, t.substate, t.impact, t.effort_days, t.scored,
+                 t.dispatch_host, t.kind, t.wave, t.created_at, t.updated_at
+            FROM tasks t JOIN workstreams w ON w.id = t.workstream_id`,
+  // Notes are a GROW-ONLY SET whose local surrogate id is not portable,
+  // so identity for diffing is (task, author, content, created_at) —
+  // exactly the identity syncNotes (src/apply.ts) folds notes by. Using the
+  // '#<id>' key here would report drift on every note that replayed to a
+  // different rowid, which is normal and not drift.
+  //
+  // char(31) (ASCII Unit Separator) joins the parts: it cannot occur in a
+  // workstream/task id and is vanishingly unlikely in note prose, so two
+  // distinct notes cannot collide into one composite key. A literal NUL
+  // would be the textbook choice but SQLite truncates TEXT at NUL.
+  task_notes: `SELECT w.name || '/' || t.local_id || char(31) ||
+                      COALESCE(n.author, '') || char(31) || n.content || char(31) ||
+                      n.created_at AS key,
+                      n.author, n.content, n.created_at, n.kind
+                 FROM task_notes n
+                 JOIN tasks t ON t.id = n.task_id
+                 JOIN workstreams w ON w.id = t.workstream_id`,
+  task_edges: `SELECT wf.name || '/' || f.local_id || '->' || wt.name || '/' || t.local_id AS key,
+                      e.created_at
+                 FROM task_edges e
+                 JOIN tasks f ON f.id = e.from_task_id
+                 JOIN tasks t ON t.id = e.to_task_id
+                 JOIN workstreams wf ON wf.id = f.workstream_id
+                 JOIN workstreams wt ON wt.id = t.workstream_id`
+};
+function snapshot(db, table) {
+  const sql = SNAPSHOT_SQL[table];
+  if (sql === void 0) throw new Error(`no drift snapshot defined for table ${table}`);
+  const out = /* @__PURE__ */ new Map();
+  for (const row of db.prepare(sql).all()) {
+    const key = row.key;
+    if (typeof key !== "string") continue;
+    out.set(key, row);
+  }
+  return out;
+}
+function show(v) {
+  if (v === null || v === void 0) return null;
+  return String(v);
+}
+function checkDrift(db) {
+  const started = Date.now();
+  const dir = mkdtempSync(join(tmpdir(), "mu-drift-"));
+  const target = join(dir, "rebuilt.db");
+  try {
+    rebuildInto(db, { targetPath: target });
+    const rebuilt = openDb({ path: target });
+    try {
+      const records = [];
+      const rowsCompared = {};
+      let total = 0;
+      const push = (record) => {
+        total += 1;
+        if (records.length < DRIFT_REPORT_CAP) records.push(record);
+      };
+      for (const table of Object.keys(SNAPSHOT_SQL)) {
+        const live = snapshot(db, table);
+        const expected = snapshot(rebuilt, table);
+        rowsCompared[table] = live.size;
+        for (const [key, liveRow] of live) {
+          const expectedRow = expected.get(key);
+          if (expectedRow === void 0) {
+            push({
+              table,
+              key,
+              field: "<row>",
+              live: "present",
+              expected: null,
+              presence: "missing-in-rebuild"
+            });
+            continue;
+          }
+          for (const field of COMPARED[table] ?? []) {
+            const a = liveRow[field];
+            const b = expectedRow[field];
+            if (show(a) !== show(b)) {
+              push({ table, key, field, live: show(a), expected: show(b) });
+            }
+          }
+        }
+        for (const key of expected.keys()) {
+          if (live.has(key)) continue;
+          push({
+            table,
+            key,
+            field: "<row>",
+            live: null,
+            expected: "present",
+            presence: "missing-in-live"
+          });
+        }
+      }
+      return {
+        clean: total === 0,
+        records,
+        totalDrift: total,
+        rowsCompared,
+        elapsedMs: Date.now() - started
+      };
+    } finally {
+      rebuilt.close();
+    }
+  } finally {
+    rmSync2(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+  }
+}
+function formatDriftRecord(record) {
+  if (record.field === "<row>") {
+    return record.presence === "missing-in-live" ? `${record.table} ${record.key}: row MISSING from live tables (the log says it exists)` : `${record.table} ${record.key}: row present in live tables but the log cannot explain it`;
+  }
+  const live = record.live === null ? "NULL" : record.live;
+  const expected = record.expected === null ? "NULL" : record.expected;
+  return `${record.table} ${record.key}.${record.field}: live=${live} log=${expected}`;
+}
+function driftRemediation() {
+  return [
+    "Drift means the ops log and the live tables disagree. One of them is wrong.",
+    "",
+    "  * If CAPTURE missed a mutation, the LIVE tables hold work the log never",
+    "    recorded. Rebuilding would DISCARD it. Do not rebuild reflexively.",
+    "  * If APPLY is lossy, the log is authoritative and a rebuild is the fix.",
+    "",
+    "Do this, in order:",
+    "  1. Back up first, before anything else:  mu db backup /tmp/mu-drift-evidence.db",
+    "  2. Materialize what the log believes:    mu rebuild /tmp/mu-rebuilt.db",
+    "  3. Compare the two by hand for the keys named above, and decide which",
+    "     side is correct. `mu db query` against both files is the fastest way.",
+    "  4. Report it: drift is a capture/apply BUG, not operator error. The",
+    "     named table/key/field above is the reproduction."
+  ];
+}
+var DriftDetectedError = class extends Error {
+  constructor(totalDrift, records) {
+    super(
+      `ops-log drift: ${totalDrift} divergence${totalDrift === 1 ? "" : "s"} between the live tables and the ops log`
+    );
+    this.totalDrift = totalDrift;
+    this.records = records;
+    this.name = "DriftDetectedError";
+  }
+  totalDrift;
+  records;
+};
+
+// src/fleet-hazards.ts
+import { existsSync as existsSync2, lstatSync, readlinkSync, realpathSync, statfsSync } from "fs";
+import { basename, dirname as dirname2, join as join2, resolve, sep } from "path";
+var HazardFailError = class extends Error {
+  constructor(failedRows) {
+    super(
+      `doctor: ${failedRows.length} row${failedRows.length === 1 ? "" : "s"} failed (${failedRows.join(", ")}); see the remediation above`
+    );
+    this.failedRows = failedRows;
+  }
+  failedRows;
+  name = "HazardFailError";
+};
+var DbInsideSyncDirError = class extends Error {
+  constructor(dbPath, syncDir) {
+    super(
+      `DB ${dbPath} is inside MU_SYNC_DIR ${syncDir}: move it out (WAL files do not sync safely)`
+    );
+    this.dbPath = dbPath;
+    this.syncDir = syncDir;
+  }
+  dbPath;
+  syncDir;
+  name = "DbInsideSyncDirError";
+};
+function canonicalPath(path, hops = 0) {
+  const abs = resolve(path);
+  const tail = [];
+  let cur = abs;
+  for (; ; ) {
+    try {
+      return join2(realpathSync(cur), ...tail);
+    } catch {
+      try {
+        if (hops < 32 && lstatSync(cur).isSymbolicLink()) {
+          return join2(canonicalPath(resolve(dirname2(cur), readlinkSync(cur)), hops + 1), ...tail);
+        }
+      } catch {
+      }
+      const parent = dirname2(cur);
+      if (parent === cur) return abs;
+      tail.unshift(basename(cur));
+      cur = parent;
+    }
+  }
+}
+function isPathInside(child, parent) {
+  const c = canonicalPath(child);
+  const p = canonicalPath(parent);
+  if (c === p) return true;
+  return c.startsWith(p.endsWith(sep) ? p : p + sep);
+}
+function checkDbInsideSyncDir(dbPath, syncDir) {
+  if (syncDir === void 0 || syncDir.trim() === "") {
+    return {
+      name: "db-vs-sync",
+      severity: "ok",
+      detail: "MU_SYNC_DIR not set (no sync configured)"
+    };
+  }
+  if (!isPathInside(dbPath, syncDir)) {
+    return { name: "db-vs-sync", severity: "ok", detail: "DB is outside the sync dir" };
+  }
+  return {
+    name: "db-vs-sync",
+    severity: "fail",
+    detail: `DB is INSIDE MU_SYNC_DIR \u2014 this WILL corrupt it (${dbPath})`,
+    remediation: [
+      "The mu database must never live inside the synced folder.",
+      "",
+      "A live WAL-mode SQLite DB is three files (mu.db, -wal, -shm) whose mutual",
+      "consistency is the basis of durability. File-sync tools copy whole files,",
+      "out of order, and across machines: a stale -wal resurrected from a peer, or",
+      "a main file copied mid-checkpoint, yields a DB that OPENS FINE and is",
+      "silently corrupt. Two machines writing the same synced file is worse \u2014 last",
+      "writer wins on the whole FILE, so one machine's entire history disappears.",
+      "",
+      "mu syncs append-only per-machine SEGMENTS precisely to avoid this: one",
+      "writer per file, never contended, so any file-mover is adequate transport.",
+      "",
+      "Fix: move the DB out of the sync dir, e.g.",
+      "  export MU_DB_PATH=$HOME/.local/state/mu-next/mu.db",
+      "and keep MU_SYNC_DIR pointing at the shared folder for segments only."
+    ]
+  };
+}
+var NETWORK_FS_MAGIC = /* @__PURE__ */ new Map([
+  // Every value here is transcribed from linux/magic.h, not recalled.
+  // An invented magic is worse than a missing one: it would either never
+  // match (silent no-op) or match the wrong filesystem and warn falsely.
+  [26985, "NFS"],
+  // NFS_SUPER_MAGIC
+  [4283649346, "CIFS/SMB"],
+  // CIFS_SUPER_MAGIC
+  [4266872130, "SMB2"],
+  // SMB2_SUPER_MAGIC
+  [20859, "SMBFS"],
+  // SMB_SUPER_MAGIC
+  [1702057286, "FUSE (may be sshfs/rclone/cloud drive)"],
+  // FUSE_SUPER_MAGIC
+  [12805120, "Ceph"]
+  // CEPH_SUPER_MAGIC
+]);
+function classifyFsType(magic, platform = process.platform) {
+  if (platform !== "linux") {
+    return { kind: "unknown", label: `unrecognised (${platform})` };
+  }
+  const network = NETWORK_FS_MAGIC.get(magic);
+  if (network !== void 0) return { kind: "network", label: network };
+  return { kind: "local", label: `local (0x${magic.toString(16)})` };
+}
+function probeFilesystem(path) {
+  try {
+    let probeTarget = resolve(path);
+    while (!existsSync2(probeTarget)) {
+      const parent = resolve(probeTarget, "..");
+      if (parent === probeTarget) break;
+      probeTarget = parent;
+    }
+    const stats = statfsSync(probeTarget);
+    return classifyFsType(Number(stats.type));
+  } catch {
+    return { kind: "unknown", label: "probe failed" };
+  }
+}
+function checkNetworkMount(dbPath, probe = probeFilesystem(dbPath)) {
+  if (probe.kind === "network") {
+    return {
+      name: "db-filesystem",
+      severity: "warn",
+      detail: `DB is on a network mount (${probe.label}) \u2014 WAL locking is unreliable there`,
+      remediation: [
+        `The DB appears to live on ${probe.label}.`,
+        "",
+        "SQLite's WAL mode needs working POSIX advisory locks AND a shared-memory",
+        "file. NFS, SMB/CIFS and FUSE mounts (sshfs, rclone, cloud drives) provide",
+        "neither dependably. Expect 'database is locked' with no contention, or",
+        "silent corruption with real contention from parallel mu invocations.",
+        "",
+        "Fix: keep the DB on local disk and sync SEGMENTS instead \u2014",
+        "  export MU_DB_PATH=$HOME/.local/state/mu-next/mu.db",
+        "That is what the segment design is for: append-only, single-writer files",
+        "that any file-mover can carry safely."
+      ]
+    };
+  }
+  if (probe.kind === "unknown") {
+    return {
+      name: "db-filesystem",
+      severity: "ok",
+      detail: `filesystem not classifiable on this platform (${probe.label}); assuming local`
+    };
+  }
+  return { name: "db-filesystem", severity: "ok", detail: `DB is on ${probe.label}` };
+}
+function findCaseCollisions(db) {
+  const rows = db.prepare("SELECT name FROM workstreams ORDER BY name").all();
+  const byFolded = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const folded = row.name.toLowerCase();
+    const bucket = byFolded.get(folded);
+    if (bucket === void 0) byFolded.set(folded, [row.name]);
+    else bucket.push(row.name);
+  }
+  const collisions = [];
+  for (const [folded, names] of byFolded) {
+    if (names.length > 1) collisions.push({ folded, names });
+  }
+  return collisions;
+}
+function checkCaseCollisions(db) {
+  const collisions = findCaseCollisions(db);
+  if (collisions.length === 0) {
+    return {
+      name: "name-case",
+      severity: "ok",
+      detail: "no case-colliding workstream names"
+    };
+  }
+  const shown = collisions.slice(0, 5).map((c) => c.names.join(" / ")).join(", ");
+  return {
+    name: "name-case",
+    severity: "warn",
+    detail: `${collisions.length} case-colliding workstream name(s): ${shown}`,
+    remediation: [
+      "These workstream names differ only by letter case:",
+      ...collisions.map((c) => `  ${c.names.join("  /  ")}`),
+      "",
+      "They coexist on Linux (ext4 is case-sensitive) but COLLIDE on macOS (APFS",
+      "is case-insensitive) and on Windows (NTFS). Because a workstream name IS a",
+      "tmux session name and seeds every worktree path, a Mac in the fleet sees",
+      "one session and one directory where Linux sees two \u2014 so the fleet reaches",
+      "different states depending on which machine applies an op first.",
+      "",
+      "Fix: rename one side to a distinct name before adding a Mac to the fleet.",
+      "There is no in-place rename verb; back the DB up, re-init under the new",
+      "name, and tear down the old one:",
+      "  mu db backup <file>",
+      "  mu workstream init <new-name>",
+      "  mu workstream teardown <old-name>      # preview; then apply with --if <rev>"
+    ]
+  };
+}
+function checkFleetHazards(db, opts = { dbPath: "" }) {
+  const syncDir = opts.syncDir !== void 0 ? opts.syncDir : process.env.MU_SYNC_DIR;
+  return [
+    checkDbInsideSyncDir(opts.dbPath, syncDir),
+    checkNetworkMount(opts.dbPath),
+    checkCaseCollisions(db)
+  ];
+}
+function checkSegmentVersion(db, syncDir) {
+  if (syncDir === void 0 || syncDir.trim() === "") {
+    return { name: "segment-version", severity: "ok", detail: "MU_SYNC_DIR not set" };
+  }
+  const found = ownSegmentForeignLine(db, syncDir);
+  if (found === null) {
+    return { name: "segment-version", severity: "ok", detail: "own segment readable by this mu" };
+  }
+  return {
+    name: "segment-version",
+    severity: "warn",
+    detail: foreignVersionMessage({ segmentPath: found.path, foreignVersion: found.version }),
+    remediation: [
+      `Line ${found.line} of the segment was written by a newer mu. This mu appends nothing`,
+      "and repairs nothing there; new ops stay in the local DB and are written",
+      "once mu is upgraded on this machine."
+    ]
+  };
+}
+var GUARD_LIST_CAP = 10;
+function listIds(rows) {
+  const shown = rows.slice(0, GUARD_LIST_CAP).map((r) => r.id);
+  return rows.length > GUARD_LIST_CAP ? `${shown.join(", ")}, \u2026 (${rows.length} total)` : shown.join(", ");
+}
+function checkOrphanedAgents(db) {
+  const rows = db.prepare(
+    `SELECT w.name AS ws, a.name AS agent, a.pane_id AS pane
+         FROM agents a JOIN workstreams w ON w.id = a.workstream_id
+        WHERE w.torn_down_at IS NOT NULL
+        ORDER BY w.name, a.name`
+  ).all();
+  if (rows.length === 0) {
+    return {
+      name: "orphaned-agents",
+      severity: "ok",
+      detail: "no agent rows in torn-down workstreams"
+    };
+  }
+  const shown = rows.slice(0, GUARD_LIST_CAP).map((r) => `${r.ws}/${r.agent} (${r.pane})`);
+  return {
+    name: "orphaned-agents",
+    severity: "warn",
+    detail: `${rows.length} agent row(s) in torn-down workstreams: ${shown.join(", ")}${rows.length > GUARD_LIST_CAP ? ", \u2026" : ""}`,
+    remediation: [
+      "Their panes may still run. Per row: `mu agent close <agent> -w <ws>` (kills the pane; keeps the row while it lives)."
+    ]
+  };
+}
+function checkCloseGuards(db) {
+  const key = "w.name || '/' || t.local_id";
+  const openBlockers2 = db.prepare(
+    `SELECT ${key} AS id
+         FROM tasks t JOIN workstreams w ON w.id = t.workstream_id AND w.torn_down_at IS NULL
+        WHERE t.status = 'CLOSED' AND t.substate = 'done'
+          AND EXISTS (SELECT 1 FROM blockers b WHERE b.task_id = t.id)
+        ORDER BY 1`
+  ).all();
+  const noEvidence = db.prepare(
+    `SELECT ${key} AS id
+         FROM tasks t JOIN workstreams w ON w.id = t.workstream_id AND w.torn_down_at IS NULL
+        WHERE t.status = 'CLOSED'
+          AND NOT EXISTS (SELECT 1 FROM task_notes n WHERE n.task_id = t.id AND n.kind = 'close')
+        ORDER BY 1`
+  ).all();
+  const row = (name, found, what, fix) => found.length === 0 ? { name, severity: "ok", detail: `no ${what}` } : {
+    name,
+    severity: "warn",
+    detail: `${found.length} ${what}: ${listIds(found)}`,
+    remediation: [fix]
+  };
+  return [
+    row(
+      "closed-blockers",
+      openBlockers2,
+      "CLOSED/done task(s) with open blockers",
+      "A peer merged these states (the local guard refuses them). Inspect with `mu task tree <id>`; reopen or close the blockers."
+    ),
+    row(
+      "closed-evidence",
+      noEvidence,
+      "CLOSED task(s) with no close note",
+      'A peer merged the close without its evidence note. Per listed task: `mu task open <ws>/<id>`, then `mu task close <ws>/<id> --evidence "<command + result>"` (close its open blockers first).'
+    )
+  ];
+}
+function checkUnpublishedOps(db, syncDir) {
+  if (syncDir === void 0 || syncDir.trim() === "") {
+    return { name: "unpublished-ops", severity: "ok", detail: "MU_SYNC_DIR not set" };
+  }
+  const n = countUnpublishedOps(db, syncDir);
+  if (n === 0) {
+    return { name: "unpublished-ops", severity: "ok", detail: "every own op is in the segment" };
+  }
+  return {
+    name: "unpublished-ops",
+    severity: "warn",
+    detail: `${n} own op(s) not yet in this machine's segment; peers cannot see them`,
+    remediation: [
+      "Run `mu sync`: it flushes the backlog. If it reports the segment as locked,",
+      "another mu process holds the lock (a stale one is broken after 30s)."
+    ]
+  };
+}
+
+// src/glyphs.ts
+var AGENT_STATE_GLYPH = {
+  busy: "\uF04B",
+  // nf-fa-play
+  needs_input: "\uF186",
+  // nf-fa-moon_o
+  needs_permission: "\uF023",
+  // nf-fa-lock
+  unknown: "\uF059"
+  // nf-fa-question_circle
+};
+function agentStateGlyph(state) {
+  return AGENT_STATE_GLYPH[state] ?? GLYPH.unknown;
+}
+var GLYPH = {
+  /** Healthy, clean, passing, closed-successfully. */
+  ok: "\uF058",
+  // nf-fa-check_circle
+  /** Failed check. */
+  fail: "\uF057",
+  // nf-fa-times_circle
+  /** Needs attention but not broken (idle-but-assigned, stale warning). */
+  warn: "\uF071",
+  // nf-fa-warning
+  /** Task is blocked by an incoming edge. */
+  blocked: "\uF0C1",
+  // nf-fa-link (chain)
+  /** Task is parked (OPEN/parked): open, but set aside on purpose. */
+  parked: "\uF04C",
+  // nf-fa-pause
+  /** Track whose roots merged (diamond dependency). */
+  merge: "\uF074",
+  // nf-fa-random
+  /** Agent owns more than one task (pane-title multi-count slot). */
+  multi: "\uF055",
+  // nf-fa-plus_circle
+  /** Filter toggle: enabled / disabled. */
+  on: "\uF111",
+  // nf-fa-circle
+  off: "\uF10C",
+  // nf-fa-circle_o
+  /** Status outside the known enum. */
+  unknown: "\uF059"
+  // nf-fa-question_circle
+};
+
+// src/wait-types.ts
+var WAIT_HEARTBEAT_CAP_MS = 15e5;
+var DEFAULT_STUCK_AFTER_MS = 12e4;
+var DEFAULT_CTL_STUCK_AFTER_MS = 5e3;
+var WaitNothingError = class extends Error {
+  name = "WaitNothingError";
+  constructor() {
+    super("wait: nothing to wait for (no refs given and none owed to this caller)");
+  }
+};
+var WaveNotFoundError = class extends Error {
+  constructor(wave, yours) {
+    super(say("wait.wave_not_found", wave, yours));
+    this.wave = wave;
+  }
+  wave;
+  name = "WaveNotFoundError";
+};
+var WaitRefError = class extends Error {
+  name = "WaitRefError";
+};
+
+// src/wait-regex.ts
+import { createContext, Script } from "vm";
+var WAIT_REGEX_MAX_LEN = 200;
+var WAIT_TEXT_MAX = 8192;
+var WAIT_REGEX_TIMEOUT_MS = 50;
+var MAX_COUNT = 1e3;
+var WaitRegexError = class extends Error {
+  name = "WaitRegexError";
+};
+function quantifierAt(src, i) {
+  const c = src[i];
+  if (c === "*" || c === "+" || c === "?") return { len: 1, counts: [] };
+  if (c !== "{") return void 0;
+  const m = /^\{(\d+)(?:,(\d*))?\}/.exec(src.slice(i, i + 24));
+  if (m === null) return void 0;
+  const counts2 = [Number(m[1])];
+  if (m[2] !== void 0 && m[2] !== "") counts2.push(Number(m[2]));
+  return { len: m[0].length, counts: counts2 };
+}
+function refuse(why) {
+  throw new WaitRegexError(`--until-text: ${why}`);
+}
+function checkRegexGrammar(src) {
+  if (src === "") refuse("the pattern is empty");
+  if (src.length > WAIT_REGEX_MAX_LEN) {
+    refuse(`the pattern is ${src.length} characters; the limit is ${WAIT_REGEX_MAX_LEN}`);
+  }
+  if (/[\u0000-\u001f\u007f]/.test(src)) refuse("the pattern has control characters");
+  const stack = [];
+  let top = { quant: false, alt: false };
+  let inClass = false;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (c === "\\") {
+      const n = src[i + 1] ?? "";
+      if (/[1-9k]/.test(n)) refuse("backreferences are not supported");
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") {
+      inClass = true;
+      continue;
+    }
+    if (c === "(") {
+      if (src[i + 1] === "?") {
+        if (src[i + 2] !== ":") refuse("lookaround and named groups are not supported");
+        i += 2;
+      }
+      stack.push(top);
+      top = { quant: false, alt: false };
+      continue;
+    }
+    if (c === ")") {
+      const parent = stack.pop();
+      if (parent === void 0) refuse("unbalanced `)`");
+      const q2 = quantifierAt(src, i + 1);
+      if (q2 !== void 0 && (top.quant || top.alt)) {
+        refuse("a repeated group may not contain a repeat or an alternation");
+      }
+      parent.quant ||= top.quant || q2 !== void 0;
+      parent.alt ||= top.alt;
+      top = parent;
+      continue;
+    }
+    if (c === "|") {
+      top.alt = true;
+      continue;
+    }
+    const q = quantifierAt(src, i);
+    if (q !== void 0) {
+      if (q.counts.some((n) => n > MAX_COUNT)) refuse(`a repeat count is over ${MAX_COUNT}`);
+      top.quant = true;
+      i += q.len - 1;
+    }
+  }
+  if (stack.length > 0) refuse("unbalanced `(`");
+}
+var SCRIPT = new Script("new RegExp(src).test(text)");
+function compileTextMatcher(src) {
+  checkRegexGrammar(src);
+  try {
+    new RegExp(src);
+  } catch (e) {
+    refuse(`not a valid regular expression (${e instanceof Error ? e.message : String(e)})`);
+  }
+  const ctx = createContext({ src, text: "" });
+  return {
+    source: src,
+    test(text) {
+      ctx.text = text.length > WAIT_TEXT_MAX ? text.slice(-WAIT_TEXT_MAX) : text;
+      try {
+        return SCRIPT.runInContext(ctx, { timeout: WAIT_REGEX_TIMEOUT_MS }) === true;
+      } catch (e) {
+        throw new WaitRegexError(
+          `--until-text: matching exceeded ${WAIT_REGEX_TIMEOUT_MS} ms (${e instanceof Error ? e.message : String(e)}); use a simpler pattern`
+        );
+      }
+    }
+  };
+}
+
+// src/close-block.ts
+var HEADER = /^CLOSE: task=(\S+) evidence="(.*)"$/;
+var TEMPLATE = /^CLOSE:[ \t]+task=<[^>\s]*>/;
+var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+var FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+function quotedLines(lines) {
+  const quoted = [];
+  let open;
+  for (const line of lines) {
+    if (open) {
+      quoted.push(true);
+      const c = FENCE_CLOSE.exec(line);
+      const run2 = c?.[1] ?? "";
+      if (run2[0] === open.ch && run2.length >= open.len) open = void 0;
+      continue;
+    }
+    const o = FENCE_OPEN.exec(line);
+    const run = o?.[1] ?? "";
+    if (o && !(run[0] === "`" && (o[2] ?? "").includes("`"))) {
+      open = { ch: run[0], len: run.length };
+      quoted.push(true);
+    } else {
+      quoted.push(false);
+    }
+  }
+  return { quoted, unclosed: open !== void 0 };
+}
+var isStart = (line) => line.startsWith("CLOSE:") && !TEMPLATE.test(line);
+var none = (reason) => ({ kind: "none", reason });
+var malformed = (reason) => ({ kind: "malformed", reason });
+function parseCloseBlock(text) {
+  if (text.trim() === "") return none("empty message");
+  const body = text.replace(/(?:\r?\n)+$/, "");
+  const raw = body.split("\n");
+  const offsets = [];
+  let at = 0;
+  for (const l of raw) {
+    offsets.push(at);
+    at += l.length + 1;
+  }
+  const lines = raw.map((l) => l.replace(/\r$/, ""));
+  const { quoted, unclosed } = quotedLines(lines);
+  if (unclosed) return none("the message ends inside a code fence");
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (!quoted[i] && isStart(lines[i] ?? "")) start = i;
+  }
+  if (start < 0) return none("no CLOSE: line at column 0");
+  const m = HEADER.exec(lines[start] ?? "");
+  if (!m) return malformed('the CLOSE: line is not `CLOSE: task=<id> evidence="<text>"`');
+  const task = m[1] ?? "";
+  if (!isValidTaskId(task)) return malformed("task= is not a valid task id");
+  const evidence = unescapeEvidence(m[2] ?? "");
+  if (evidence === void 0) return malformed("evidence has a bare or unterminated quote");
+  if (evidence.trim() === "") return malformed("evidence is empty");
+  if (start + 1 >= lines.length || lines[start + 1] !== "REPORT:") {
+    return malformed("the line after CLOSE: is not exactly REPORT:");
+  }
+  const report = body.slice(offsets[start + 2] ?? body.length);
+  if (report.trim() === "") return malformed("the report is empty");
+  const normalized = body.length < text.length ? `${report}
+` : report;
+  return { kind: "valid", task, evidence, report: normalized };
+}
+function unescapeEvidence(body) {
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === '"') return void 0;
+    if (c !== "\\") {
+      out += c;
+      continue;
+    }
+    const n = body[i + 1];
+    if (n === '"' || n === "\\") {
+      out += n;
+      i++;
+    } else if (n === "n") {
+      out += "\n";
+      i++;
+    } else if (n === void 0) {
+      return void 0;
+    } else {
+      out += c;
+    }
+  }
+  return out;
+}
+var CLOSE_MALFORMED = "no close (malformed)";
+var CLOSE_TRUNCATED = "CLOSE block not applied: the final message was truncated; close with mu task close";
+var no = (reason, task = null) => ({
+  applied: false,
+  task,
+  reason
+});
+function applySettledClose(db, input) {
+  if (!input.settled) return no("not settled");
+  if (input.lastError !== void 0) return no("run ended on an error");
+  return withOpContext(
+    db,
+    { intent: "close.apply", actor: input.agent, group: "new" },
+    () => applyInTxn(db, input)
+  );
+}
+function applyInTxn(db, input) {
+  const agent = db.prepare(
+    `SELECT a.cli FROM agents a JOIN workstreams w ON w.id = a.workstream_id
+        WHERE a.id = ? AND a.name = ? AND w.name = ? AND w.torn_down_at IS NULL`
+  ).get(input.agentId, input.agent, input.workstream);
+  if (!agent) return no("unknown agent");
+  if (agent.cli !== "pi") return no("not a pi agent");
+  const seen = db.prepare("SELECT 1 FROM agent_settles WHERE agent_id = ? AND incarnation = ? AND runs = ?").get(input.agentId, input.incarnation, input.runs);
+  if (seen) return no("already applied");
+  const record = (taskId) => {
+    db.prepare(
+      "INSERT INTO agent_settles (agent_id, incarnation, runs, task_id) VALUES (?, ?, ?, ?)"
+    ).run(input.agentId, input.incarnation, input.runs, taskId);
+  };
+  const diagnose = (reason) => {
+    const open = db.prepare(
+      `SELECT t.local_id FROM tasks t JOIN workstreams w ON w.id = t.workstream_id
+          WHERE t.owner_id = ? AND t.status = 'IN_PROGRESS' AND w.name = ?`
+    ).all(input.agentId, input.workstream);
+    const only = open.length === 1 ? open[0]?.local_id ?? null : null;
+    if (only !== null) {
+      addNote(db, only, reason, {
+        workstream: input.workstream,
+        author: input.agent,
+        group: "inherit"
+      });
+    }
+    record(null);
+    return no(reason, only);
+  };
+  if (input.lastTextTruncated === true) return diagnose(CLOSE_TRUNCATED);
+  const block = parseCloseBlock(input.lastText);
+  if (block.kind === "none") return no(`no CLOSE block: ${block.reason}`);
+  if (block.kind === "malformed") return diagnose(`${CLOSE_MALFORMED}: ${block.reason}`);
+  const task = db.prepare(
+    `SELECT t.id, t.status, t.owner_id, t.kind FROM tasks t JOIN workstreams w ON w.id = t.workstream_id
+        WHERE w.name = ? AND w.torn_down_at IS NULL AND t.local_id = ?`
+  ).get(input.workstream, block.task);
+  if (task?.kind === "human") {
+    record(task.id);
+    return no(
+      `human task: close it with \`mu task close ${block.task} -w ${input.workstream}\``,
+      block.task
+    );
+  }
+  if (task?.kind === "delegate") {
+    record(task.id);
+    return no("delegate task: its call records the answer and closes it", block.task);
+  }
+  if (!task || task.owner_id !== input.agentId) {
+    record(null);
+    return no("task is not owned by this agent", block.task);
+  }
+  if (task.status === "CLOSED") {
+    record(task.id);
+    return no("task already closed", block.task);
+  }
+  closeTask(db, block.task, {
+    workstream: input.workstream,
+    evidence: block.evidence,
+    report: block.report,
+    author: input.agent,
+    group: "inherit"
+  });
+  record(task.id);
+  return { applied: true, task: block.task, reason: "closed" };
+}
+
+// src/wait-db.ts
+function closeSettledRun(db, ref, r, enabled) {
+  if (!enabled || r.settled !== true) return void 0;
+  const row = db.prepare(
+    `SELECT a.id FROM agents a JOIN workstreams w ON w.id = a.workstream_id
+        WHERE a.name = ? AND w.name = ?`
+  ).get(ref.id, ref.workstream);
+  const facts = settledCloseInput({
+    workstream: ref.workstream,
+    name: ref.id,
+    agentId: r.agentId ?? row?.id ?? 0,
+    status: r.status,
+    settled: true,
+    ...r.incarnation !== void 0 ? { incarnation: r.incarnation } : {},
+    ...r.runs !== void 0 ? { runs: r.runs } : {},
+    ...r.lastText !== void 0 ? { lastText: r.lastText } : {},
+    ...r.lastTextTruncated !== void 0 ? { lastTextTruncated: r.lastTextTruncated } : {},
+    ...r.lastError !== void 0 ? { lastError: r.lastError } : {}
+  });
+  if (facts === void 0) return void 0;
+  try {
+    const res = applySettledClose(db, facts);
+    return { applied: res.applied, task: res.task, reason: res.reason };
+  } catch (e) {
+    return { applied: false, task: null, reason: e instanceof Error ? e.message : String(e) };
+  }
+}
+function agentExists(db, ref) {
+  return db.prepare(
+    `SELECT 1 FROM agents a JOIN workstreams ws ON ws.id = a.workstream_id
+          WHERE a.name = ? AND ws.name = ?`
+  ).get(ref.id, ref.workstream) !== void 0;
+}
+function openBlockers(db, umbrella) {
+  return db.prepare(BLOCKERS_SQL).all(umbrella);
+}
+var BLOCKERS_SQL = `
+  WITH RECURSIVE reach(node) AS (
+    SELECT e.from_task_id FROM task_edges e WHERE e.to_task_id = ?
+    UNION
+    SELECT e.from_task_id FROM task_edges e
+      JOIN reach r ON e.to_task_id = r.node
+      JOIN tasks t ON t.id = r.node
+     WHERE t.status <> 'CLOSED'
+  )
+  SELECT t.local_id AS id, w.name AS ws FROM reach r
+    JOIN tasks t ON t.id = r.node JOIN workstreams w ON w.id = t.workstream_id
+   ORDER BY w.name, t.local_id`;
+function agentRowId(db, ref) {
+  const row = db.prepare(
+    `SELECT a.id FROM agents a JOIN workstreams ws ON ws.id = a.workstream_id
+        WHERE a.name = ? AND ws.name = ?`
+  ).get(ref.id, ref.workstream);
+  return row?.id ?? 0;
+}
+function opsHead(db) {
+  return db.prepare("SELECT COALESCE(MAX(seq), 0) AS s FROM ops").get().s;
+}
+function reapFlip(db, ref, since) {
+  const key = `${ref.workstream}/${ref.id}`;
+  const last = db.prepare(
+    `SELECT seq, intent FROM ops WHERE entity = 'task' AND key = ?
+          AND (json_extract(payload, '$.status') IS NOT NULL OR json_extract(payload, '$.substate') IS NOT NULL)
+        ORDER BY seq DESC LIMIT 1`
+  ).get(key);
+  if (last === void 0 || last.intent !== "task.reap" || last.seq <= since) return void 0;
+  const owner = db.prepare(
+    `SELECT json_extract(payload, '$.owner_id') AS id, actor FROM ops
+        WHERE entity = 'task' AND key = ? AND seq < ? AND json_extract(payload, '$.owner_id') IS NOT NULL
+        ORDER BY seq DESC LIMIT 1`
+  ).get(key, last.seq);
+  return {
+    seq: last.seq,
+    ownerId: Number(owner?.id ?? 0),
+    ...owner?.actor != null ? { ownerName: owner.actor } : {}
+  };
+}
+function taskOwnerRowId(db, ref) {
+  const row = db.prepare(
+    `SELECT COALESCE(t.owner_id, 0) AS id FROM tasks t JOIN workstreams ws ON ws.id = t.workstream_id
+        WHERE t.local_id = ? AND ws.name = ?`
+  ).get(ref.id, ref.workstream);
+  return row?.id ?? 0;
+}
+
+// src/wait-item.ts
+var refKey = (r) => cursorKey(r.kind, r.workstream, r.id);
+var registered = (r) => ({
+  kind: r.kind,
+  workstream: r.workstream,
+  id: r.id
+});
+var URGENCY = {
+  dead: 0,
+  input: 1,
+  stall: 2,
+  delegate: 3
+};
+var urgency = (k) => k === void 0 ? 9 : URGENCY[k] ?? 4;
+var isCompletion = (i) => i.kind === "closed" || i.kind === "settled" || i.kind === "pane-text" || i.kind === "exited" || i.kind === "delegate" || i.kind === "dead" && i.ref.kind === "agent";
+var exitFor = (k) => k === "dead" ? 6 : k === "input" || k === "stall" ? 7 : k === "interrupted" ? 130 : 0;
+var inputToken = (r) => ({
+  incarnation: `input:${r.incarnation ?? ""}`,
+  runs: r.blocked?.since ?? 0
+});
+var agentSnapshot = (t) => {
+  const r = t.latched?.reading ?? t.reading;
+  const status = t.latched?.kind === "dead" || t.latched?.kind === "exited" ? null : r?.status ?? "unknown";
+  return {
+    ref: t.ref,
+    status,
+    ...r?.agentId !== void 0 ? { agentId: r.agentId } : {},
+    ...r?.paneId !== void 0 ? { paneId: r.paneId } : {},
+    ...r?.settled !== void 0 ? { settled: r.settled } : {},
+    ...r?.lastTextTruncated !== void 0 ? { lastTextTruncated: r.lastTextTruncated } : {},
+    ...r?.textSource !== void 0 ? { textSource: r.textSource } : {},
+    ...r?.incarnation !== void 0 ? { incarnation: r.incarnation } : {},
+    ...r?.runs !== void 0 ? { runs: r.runs } : {},
+    ...r?.lastText !== void 0 ? { lastText: r.lastText } : {},
+    ...r?.lastError !== void 0 ? { lastError: r.lastError } : {},
+    ...r?.sessionFile !== void 0 ? { sessionFile: r.sessionFile } : {},
+    ...r?.blocked !== void 0 ? { blocked: r.blocked } : {},
+    ...t.latched?.kind === "exited" && r?.exit !== void 0 ? { exit: r.exit } : {},
+    ...status === "unknown" && r?.reason !== void 0 ? { unknownReason: r.reason } : {},
+    ...t.baseline !== void 0 ? { afterRuns: t.baseline } : {},
+    wasBusy: t.wasBusy,
+    ...t.unknownBaseline ? { unknownBaseline: true } : {},
+    fired: t.latched?.kind === "settled" || t.latched?.kind === "pane-text" || t.latched?.kind === "exited",
+    dead: t.latched?.kind === "dead",
+    ...t.close !== void 0 ? { close: t.close } : {}
+  };
+};
+var delegateItem = (call, isTarget, suppressible, order) => {
+  const ref = { kind: "delegate", workstream: call.workstream, id: call.callId };
+  const terminal = TERMINAL_DELEGATE_STATES.includes(call.state);
+  const item = {
+    key: refKey(ref),
+    ref,
+    snap: {
+      ref,
+      status: call.state,
+      verdict: call.verdict,
+      owner: call.agent,
+      // Which finding this is: the delegate's own task, the task it judges, its wave.
+      callTask: call.task,
+      ...call.record !== null ? { record: `${call.record.workstream}/${call.record.task}` } : {},
+      ...call.wave !== null ? { wave: call.wave } : {},
+      fired: terminal,
+      dead: false
+    },
+    target: isTarget,
+    suppressible,
+    order,
+    done: terminal,
+    ready: false
+  };
+  if (terminal) {
+    item.kind = "delegate";
+    item.token = DELEGATE_TOKEN;
+  }
+  return item;
+};
+var sameDeath = (a, b) => {
+  const task = a.ref.kind === "task" ? a : b;
+  const agent = task === a ? b : a;
+  const t = task.death;
+  const g = agent.death;
+  if (a.kind !== "dead" || b.kind !== "dead" || t === void 0 || g === void 0) return false;
+  if (task.ref.kind !== "task" || agent.ref.kind !== "agent") return false;
+  if (g.rowId !== 0) return g.rowId === t.rowId;
+  return t.name === agent.ref.id && (t.workstream === void 0 || t.workstream === agent.ref.workstream);
+};
+var failedGate = (i) => i.kind === "exited" && i.snap.exit !== void 0 && i.snap.exit !== 0;
+var snapshotsOf = (items, extra = []) => {
+  const targets = items.filter((i) => i.target);
+  const base = targets.length > 0 ? targets : items;
+  const shown = [...base];
+  for (const e of extra) if (!shown.includes(e)) shown.push(e);
+  return shown.map((i) => i.snap);
+};
+
+// src/wait-latch.ts
+function rearmLatch(t, baseline, watching) {
+  t.latched = void 0;
+  t.close = void 0;
+  t.handle = void 0;
+  t.result = void 0;
+  t.needWatch = watching;
+  t.baseline = baseline;
+  t.wasBusy = false;
+}
+function supersededBy(t, r) {
+  const held = t.latched?.kind === "settled" ? t.latched.reading : void 0;
+  if (held === void 0 || r.runs === void 0) return void 0;
+  const differs = (a, b) => a !== void 0 && b !== void 0 && a !== b;
+  if (differs(held.agentId, r.agentId) || differs(held.incarnation, r.incarnation)) return 0;
+  if (held.runs !== void 0 && r.runs > held.runs) return held.runs;
+  return void 0;
+}
+
+// src/wait.ts
+var sleepSeam;
+async function waitForEvents(db, input, opts) {
+  const callers = [...new Set(opts.callers ?? [])];
+  for (const c of callers) checkCaller(c);
+  const all = opts.mode === "all";
+  const ownedScope = opts.eventScope !== "refs";
+  const stuckExplicit = opts.stuckAfterMs;
+  const stuckEnabled = stuckExplicit !== 0 && opts.status !== "OPEN" && opts.status !== "IN_PROGRESS";
+  const stuckAfter = (viaCtl) => stuckExplicit ?? (viaCtl ? DEFAULT_CTL_STUCK_AFTER_MS : DEFAULT_STUCK_AFTER_MS);
+  const watchDeaths = callers.length > 0 || ownedScope;
+  const scope = opts.scope;
+  const inScope = (workstream) => scope === void 0 || workstream === scope;
+  const callInScope = (c) => scope === void 0 || c.workstream === scope || c.record?.workstream === scope;
+  const observeOwners = (watchDeaths || stuckEnabled) && opts.readAgents !== void 0;
+  const consumes = ownedScope && callers.length > 0;
+  const target = opts.status ?? "CLOSED";
+  const discover = consumes && target === "CLOSED";
+  const matcher = typeof opts.until === "object" ? compileTextMatcher(opts.until.text) : void 0;
+  const applyClose = opts.applyClose !== false;
+  const pollMs = opts.pollMs ?? 1e3;
+  const requested = opts.timeoutMs ?? 0;
+  const timeoutMs = opts.uncapped ? requested : requested === 0 ? WAIT_HEARTBEAT_CAP_MS : Math.min(requested, WAIT_HEARTBEAT_CAP_MS);
+  const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : Number.POSITIVE_INFINITY;
+  const sinceSeq = opts.sinceSeq ?? opsHead(db);
+  for (const ref of input) {
+    if (ref.kind === "task") {
+      if (getTask(db, ref.id, ref.workstream) === void 0) {
+        throw new TaskNotFoundError(`${ref.workstream}/${ref.id}`);
+      }
+    } else if (ref.kind === "agent") {
+      if (!agentExists(db, ref)) throw new AgentNotFoundError(ref.id);
+    } else {
+      const call = getDelegateCall(db, ref.id);
+      if (call === void 0 || call.workstream !== ref.workstream) {
+        throw new DelegateNotFoundError(ref.id);
+      }
+      if (callers.length > 0 && !callers.includes(call.caller)) {
+        throw new WaitRefError(`delegate call ${ref.id} belongs to another caller`);
+      }
+      if (call.state === "refused") {
+        throw new WaitRefError(
+          `delegate call ${ref.id} was refused (it never started): reissue it, mu_delegate_reissue`
+        );
+      }
+    }
+  }
+  const umbrella = opts.blockersOf === void 0 ? void 0 : taskIdFor(db, opts.blockersOf.id, opts.blockersOf.workstream);
+  if (opts.blockersOf !== void 0 && umbrella === null) {
+    throw new TaskNotFoundError(`${opts.blockersOf.workstream}/${opts.blockersOf.id}`);
+  }
+  const explicit = /* @__PURE__ */ new Map();
+  for (const r of input) explicit.set(refKey(r), r);
+  if (opts.wave !== void 0 && callers.length === 0) {
+    throw new WaitRefError("wait: a wave belongs to callers; none given (no all-caller fallback)");
+  }
+  if (input.length === 0 && !opts.wave && !opts.blockersOf && callers.length === 0) {
+    throw new WaitNothingError();
+  }
+  if (opts.wave !== void 0) {
+    const mine = listDelegatesOf(db, callers, opts.wave.workstream);
+    if (!mine.some((c) => c.wave === opts.wave?.name)) {
+      throw new WaveNotFoundError(
+        opts.wave.name,
+        mine.map((c) => c.wave)
+      );
+    }
+  }
+  const begun = /* @__PURE__ */ new Map();
+  if (consumes) {
+    for (const c of callers) {
+      const b = beginWait(db, c);
+      if (b !== void 0) begun.set(c, b);
+    }
+  }
+  const cursorsBy = new Map(
+    (consumes ? callers : []).map((c) => [c, readCursors(db, c)])
+  );
+  const ownerOfKey = /* @__PURE__ */ new Map();
+  const baseOfCkey = /* @__PURE__ */ new Map();
+  const urgentKey = (kind, key) => {
+    const k = `${kind}|${key}`;
+    baseOfCkey.set(k, key);
+    return k;
+  };
+  const ownerOf = (key) => ownerOfKey.get(baseOfCkey.get(key) ?? key) ?? callers[0];
+  const cursorOf = (key) => {
+    const o = ownerOf(key);
+    return o === void 0 ? void 0 : cursorsBy.get(o)?.get(key);
+  };
+  const baselineOf = /* @__PURE__ */ new Map();
+  const ownedKeys = /* @__PURE__ */ new Set();
+  const watchAbort = new AbortController();
+  let stopReason;
+  let stopNow = () => {
+  };
+  const stopP = new Promise((resolve4) => {
+    stopNow = (why) => {
+      stopReason ??= why;
+      resolve4();
+    };
+  });
+  const onAbort = () => {
+    watchAbort.abort();
+    stopNow("abort");
+  };
+  if (opts.signal?.aborted) onAbort();
+  else opts.signal?.addEventListener("abort", onAbort, { once: true });
+  const deadlineTimer = deadline === Number.POSITIVE_INFINITY ? void 0 : setTimeout(() => stopNow("deadline"), Math.max(0, deadline - Date.now()));
+  const within = (p) => Promise.race([
+    p.then((v) => ({ lost: false, v })),
+    stopP.then(() => ({ lost: true }))
+  ]);
+  let fatal;
+  let wake = () => {
+  };
+  let woken = new Promise((resolve4) => {
+    wake = resolve4;
+  });
+  const tracks = /* @__PURE__ */ new Map();
+  const ownerReadings = /* @__PURE__ */ new Map();
+  const openLocal = /* @__PURE__ */ new Set();
+  const priorTask = /* @__PURE__ */ new Map();
+  let firstRefresh = true;
+  const delivered = [];
+  const discoverSpawned = () => {
+    if (!discover) return;
+    const rows = db.prepare(
+      `SELECT a.name AS agent, a.id AS agentId, a.spawner AS spawner, aws.name AS agentWs,
+                t.local_id AS task, tws.name AS taskWs
+           FROM agents a
+           JOIN workstreams aws ON aws.id = a.workstream_id
+           JOIN tasks t ON t.owner_id = a.id AND t.status = 'IN_PROGRESS' AND t.kind = 'work'
+           JOIN workstreams tws ON tws.id = t.workstream_id AND tws.torn_down_at IS NULL
+          WHERE a.spawner IN (${callers.map(() => "?").join(",")})
+          ORDER BY a.id, t.id`
+    ).all(...callers);
+    const bySpawner = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      if (!inScope(r.taskWs) && !inScope(r.agentWs)) continue;
+      const list = bySpawner.get(r.spawner) ?? [];
+      list.push(
+        {
+          kind: "agent",
+          workstream: r.agentWs,
+          id: r.agent,
+          baseline: { afterRuns: 0, agentId: r.agentId }
+        },
+        { kind: "task", workstream: r.taskWs, id: r.task }
+      );
+      bySpawner.set(r.spawner, list);
+    }
+    for (const [spawner, refs] of bySpawner) {
+      const reg = readWaitRegistration(db, spawner);
+      const have = new Set((reg?.refs ?? []).map((r) => refKey(r)));
+      const fresh = refs.filter((r) => !have.has(refKey(r)));
+      if (fresh.length === 0) continue;
+      try {
+        registerOwnedWait(db, spawner, fresh);
+      } catch {
+      }
+    }
+  };
+  const ownedRefs = () => {
+    if (!consumes) return [];
+    const out = /* @__PURE__ */ new Map();
+    ownedKeys.clear();
+    for (const c of callers) {
+      const reg = readWaitRegistration(db, c);
+      if (reg === void 0) continue;
+      const done = reg.refs.filter(
+        (r) => r.kind === "agent" && !agentExists(db, r) && hasDoneMark(db, c, r)
+      );
+      if (done.length > 0) dropOwnedRefs(db, c, done);
+      for (const r of reg.refs) {
+        if (done.includes(r)) continue;
+        if (r.kind !== "delegate" && !inScope(r.workstream)) continue;
+        const key = refKey(r);
+        ownedKeys.add(key);
+        if (!out.has(key)) {
+          out.set(key, { ...r });
+          ownerOfKey.set(key, c);
+        }
+        const b = reg.baselines[key];
+        if (b !== void 0) {
+          const old = baselineOf.get(key);
+          if (old === void 0 || old.incarnation === b.incarnation && b.afterRuns < old.afterRuns) {
+            baselineOf.set(key, b);
+          }
+        }
+      }
+    }
+    return [...out.values()];
+  };
+  const track = (ref, isExplicit) => {
+    const key = refKey(ref);
+    let t = tracks.get(key);
+    if (t === void 0) {
+      t = {
+        ref,
+        explicit: isExplicit,
+        wasBusy: false,
+        baseline: ref.afterRuns,
+        handle: void 0,
+        needWatch: opts.watchAgent !== void 0,
+        result: void 0,
+        reading: void 0,
+        latched: void 0,
+        close: void 0,
+        muted: false,
+        unknownBaseline: false
+      };
+      tracks.set(key, t);
+    } else if (isExplicit) t.explicit = true;
+    return t;
+  };
+  const setupWatches = async () => {
+    const watch = opts.watchAgent;
+    const want = [...tracks.values()].filter((t) => t.needWatch && t.latched === void 0);
+    if (watch === void 0 || want.length === 0) return;
+    for (const t of want) t.needWatch = false;
+    const got = await within(
+      Promise.all(
+        want.map((t) => {
+          const key = refKey(t.ref);
+          const cur = cursorOf(key);
+          const base = baselineOf.get(key);
+          return watch(
+            { ...t.ref, ...t.baseline !== void 0 ? { afterRuns: t.baseline } : {} },
+            watchAbort.signal,
+            {
+              owed: ownedKeys.has(key),
+              ...cur !== void 0 ? { cursor: cur } : {},
+              ...base !== void 0 ? { baseline: base } : {}
+            }
+          );
+        })
+      )
+    );
+    if (got.lost) return;
+    got.v.forEach((h, i) => {
+      const t = want[i];
+      if (t === void 0 || h === void 0) return;
+      t.handle = h;
+      t.reading = h.initial;
+      if (t.baseline === void 0 && h.afterRuns !== void 0) t.baseline = h.afterRuns;
+      if (h.unknownBaseline !== void 0) {
+        t.unknownBaseline = true;
+        const key = refKey(t.ref);
+        const owner = ownerOf(key);
+        if (owner !== void 0 && consumes)
+          fenceAgentRef(db, owner, registered(t.ref), h.unknownBaseline);
+      }
+      if (h.initial.status === "busy") t.wasBusy = true;
+      void h.settled.then(
+        (r) => {
+          if (t.handle === h) t.result = r;
+          wake();
+        },
+        (error) => {
+          fatal ??= { error };
+          wake();
+        }
+      );
+    });
+  };
+  const settle = (t, r) => {
+    const consumed = !t.explicit && r.runs !== void 0 && isConsumed(cursorOf(refKey(t.ref)), { incarnation: r.incarnation ?? "", runs: r.runs });
+    const close = consumed ? void 0 : closeSettledRun(db, t.ref, r, applyClose);
+    const textOk = matcher === void 0 || r.lastError === void 0 && (r.lastText ?? "").trim() !== "" && matcher.test(r.lastText ?? "");
+    if (!textOk || consumed) {
+      if (r.runs !== void 0) t.baseline = r.runs;
+      t.wasBusy = false;
+      t.handle = void 0;
+      t.result = void 0;
+      t.needWatch = opts.watchAgent !== void 0;
+      return;
+    }
+    t.latched = { kind: "settled", reading: r };
+    if (close !== void 0) t.close = close;
+  };
+  const rearm = (t, baseline) => rearmLatch(t, baseline, opts.watchAgent !== void 0);
+  const advance = (t, r, fromWatch) => {
+    if (t.latched !== void 0) return;
+    const pinned = t.ref.incarnation;
+    if (pinned !== void 0 && r.incarnation !== void 0 && r.incarnation !== pinned) {
+      throw new AgentRestartedError(t.ref.id, t.ref.workstream, pinned, r.incarnation);
+    }
+    if (r.blocked === void 0 && t.muted) {
+      t.muted = false;
+      if (opts.watchAgent !== void 0 && r.status !== null) {
+        t.needWatch = true;
+        return;
+      }
+    }
+    if (r.exit !== void 0) {
+      t.latched = { kind: "exited", reading: r };
+    } else if (r.status === null) {
+      t.latched = { kind: "dead", reading: r };
+    } else if (r.blocked !== void 0) {
+      if (!t.explicit && isConsumed(cursorOf(urgentKey("input", refKey(t.ref))), inputToken(r))) {
+        t.muted = true;
+        t.wasBusy = true;
+        t.handle = void 0;
+        t.result = void 0;
+        t.needWatch = false;
+      } else t.latched = { kind: "input", reading: r };
+    } else if (!fromWatch && matcher !== void 0 && r.textSource === "pane" && r.lastText !== void 0 && matcher.test(r.lastText)) {
+      t.latched = { kind: "pane-text", reading: r };
+    } else if (fromWatch) {
+      if (r.status === "unknown") t.handle = void 0;
+      else settle(t, r);
+    } else if (r.status === "busy") {
+      t.wasBusy = true;
+    } else if (r.status !== "unknown" && t.wasBusy) {
+      settle(t, r);
+    }
+  };
+  const ownerOfAgent = (t) => ({
+    name: t.ref.id,
+    workstreamName: t.ref.workstream
+  });
+  const markOwed = () => {
+    if (!consumes) return;
+    for (const t of tracks.values()) {
+      const key = refKey(t.ref);
+      const caller = ownerOfKey.get(key);
+      const r = t.latched === void 0 ? ownerReadings.get(agentKey(ownerOfAgent(t))) : void 0;
+      if (caller === void 0 || !ownedKeys.has(key) || r === void 0) continue;
+      const id = agentRowId(db, t.ref);
+      if (id === 0) continue;
+      const owed = agentOwed(db, id, r, baselineOf.get(key), t.unknownBaseline, t.wasBusy);
+      if (owed !== "unsure")
+        setAgentDone(db, t.ref.workstream, t.ref.id, owed === "done", [caller]);
+    }
+  };
+  const refresh = async () => {
+    if (opts.beforePoll) {
+      const b = await within(opts.beforePoll());
+      if (b.lost) return;
+    }
+    if (opts.sync !== false) await ambientIngest(db, { quiet: true });
+    discoverSpawned();
+    const owned = ownedRefs();
+    for (const r of explicit.values()) if (r.kind === "agent") track(r, true);
+    for (const r of owned) if (r.kind === "agent") track(r, explicit.has(refKey(r)));
+    await setupWatches();
+    if (stopReason !== void 0) return;
+    const reads = /* @__PURE__ */ new Map();
+    for (const t of tracks.values()) {
+      if (t.latched === void 0 && t.handle === void 0 || t.latched?.kind === "settled") {
+        reads.set(refKey(t.ref), t.ref);
+      }
+    }
+    if (consumes && opts.readAgents !== void 0) {
+      for (const r of owned) {
+        const t = r.kind === "agent" ? tracks.get(refKey(r)) : void 0;
+        if (t !== void 0 && t.latched === void 0) reads.set(refKey(r), r);
+      }
+    }
+    if (observeOwners) {
+      const taskRefs = [...explicit.values(), ...owned].filter((r) => r.kind === "task");
+      for (const r of taskRefs) {
+        const row = getTask(db, r.id, r.workstream);
+        const o = row?.status === "IN_PROGRESS" ? getTaskOwner(db, r.id, r.workstream) : void 0;
+        if (o !== void 0) {
+          const ref = { kind: "agent", workstream: o.workstreamName, id: o.name };
+          reads.set(refKey(ref), ref);
+        }
+      }
+    }
+    for (const t of tracks.values()) {
+      const r = t.result;
+      if (r === void 0 || t.handle === void 0) continue;
+      t.result = void 0;
+      t.reading = r;
+      advance(t, r, true);
+    }
+    if (reads.size > 0) {
+      if (opts.readAgents === void 0) throw new Error("wait: an agent reader is required");
+      const got = await within(opts.readAgents([...reads.values()], watchAbort.signal));
+      if (got.lost) return;
+      ownerReadings.clear();
+      for (const ref of reads.values()) {
+        const key = agentKey({ name: ref.id, workstreamName: ref.workstream });
+        let r = got.v.get(key);
+        if (r === void 0) {
+          r = watchDeaths && !agentExists(db, ref) ? { status: null, reason: "agent is no longer registered" } : { status: "unknown", reason: "state reader returned no row" };
+        }
+        ownerReadings.set(key, r);
+        const t = tracks.get(refKey(ref));
+        const held = t === void 0 ? void 0 : supersededBy(t, r);
+        if (t !== void 0 && held !== void 0) {
+          rearm(t, held);
+          if (t.needWatch) continue;
+          t.wasBusy = true;
+        }
+        if (t !== void 0 && t.latched === void 0 && t.handle === void 0) {
+          t.reading = r;
+          advance(t, r, false);
+        }
+      }
+    }
+    markOwed();
+    if (firstRefresh) {
+      firstRefresh = false;
+      const watched = [...tracks.values()].filter((t) => t.explicit);
+      if (watched.length > 0 && watched.every((t) => (t.latched?.reading ?? t.reading)?.status === "unknown")) {
+        opts.onInitialUnknown?.(watched.map((t) => agentSnapshot(t)));
+      }
+    }
+  };
+  const ctlBrokenSince = /* @__PURE__ */ new Map();
+  const stallEmitted = /* @__PURE__ */ new Set();
+  const stallStates = /* @__PURE__ */ new Map();
+  const stallAgeMs = (ownerKey, r) => {
+    if (r === void 0 || r.status === null) return null;
+    const alive = true;
+    if (alive && (r.ctl === "missing" || r.ctl === "refused")) {
+      const first = ctlBrokenSince.get(ownerKey) ?? Date.now();
+      ctlBrokenSince.set(ownerKey, first);
+      const age2 = Date.now() - first;
+      return age2 >= stuckAfter(false) ? age2 : null;
+    }
+    ctlBrokenSince.delete(ownerKey);
+    if (r.status !== "needs_input" || r.since === void 0 || r.since === null) return null;
+    const viaCtl = r.source === "ctl" && r.ctl === "ok";
+    if (viaCtl && r.pending === true) return null;
+    const age = Date.now() - r.since;
+    return age >= stuckAfter(viaCtl) ? age : null;
+  };
+  const markStall = (item, stall) => {
+    const r = stall.owner;
+    item.snap.stuck = true;
+    item.snap.stuckWhy = r.ctl === "missing" || r.ctl === "refused" ? r.reason ?? `ctl ${r.ctl}` : r.status ?? "needs_input";
+    item.snap.stuckSecs = stall.ageSecs;
+    if (r.runs !== void 0) item.snap.ownerRuns = r.runs;
+    item.kind = "stall";
+    item.ckey = urgentKey("stall", item.key);
+    item.token = { incarnation: `stall:${stall.token}`, runs: 1 };
+    item.stall = stall;
+    item.snap.owner ??= stall.ownerRef.name;
+    item.snap.ownerWorkstream ??= stall.ownerRef.workstreamName;
+    if (stall.close !== void 0) item.snap.close = stall.close;
+  };
+  const taskItem = (ref, want, isTarget, suppressible, order) => {
+    const row = getTask(db, ref.id, ref.workstream);
+    const status = row?.status ?? "OPEN";
+    const ownerRef = row === void 0 ? void 0 : getTaskOwner(db, ref.id, ref.workstream);
+    const ownerName = ownerRef?.name ?? row?.ownerName ?? null;
+    const snap = {
+      ref,
+      status,
+      substate: row?.substate ?? DEFAULT_SUBSTATE.OPEN,
+      owner: ownerName,
+      ...ownerRef !== void 0 ? { ownerWorkstream: ownerRef.workstreamName } : {},
+      fired: false,
+      dead: false
+    };
+    const item = {
+      key: refKey(ref),
+      ref,
+      snap,
+      target: isTarget,
+      suppressible,
+      order,
+      done: false,
+      ready: false
+    };
+    if (row === void 0) return item;
+    if (watchDeaths && want === "CLOSED" && status !== "CLOSED") {
+      const prior = priorTask.get(item.key);
+      const ownerKey = ownerRef === void 0 ? void 0 : agentKey(ownerRef);
+      const flip = status === "OPEN" ? reapFlip(db, ref, ownedKeys.has(item.key) ? 0 : sinceSeq) : void 0;
+      const dead = ownerKey !== void 0 && ownerReadings.get(ownerKey)?.status === null || // The reaper flip seen live: IN_PROGRESS -> OPEN while the owner's row (that very row) is
+      // gone. A release leaves the owner registered; a replaced agent is another row.
+      prior?.status === "IN_PROGRESS" && status === "OPEN" && prior.owner !== null && prior.ownerId !== 0 && agentRowId(db, { workstream: prior.ownerWs, id: prior.owner }) !== prior.ownerId || flip !== void 0;
+      if (dead) {
+        snap.dead = true;
+        item.kind = "dead";
+        item.done = true;
+        item.ckey = urgentKey("dead", item.key);
+        const rowId = ownerRef !== void 0 ? taskOwnerRowId(db, ref) : prior?.ownerId || flip?.ownerId || 0;
+        item.token = { incarnation: `dead:${rowId}`, runs: 1 };
+        const name = ownerRef?.name ?? prior?.owner ?? flip?.ownerName;
+        const workstream = ownerRef?.workstreamName ?? (prior?.owner != null ? prior.ownerWs : void 0);
+        item.death = {
+          rowId,
+          ...name != null ? { name } : {},
+          ...workstream !== void 0 ? { workstream } : {}
+        };
+        return item;
+      }
+    }
+    if (stuckEnabled && status === "IN_PROGRESS" && row.kind === "work" && ownerRef !== void 0 && want === "CLOSED") {
+      const ownerKey = agentKey(ownerRef);
+      const r = ownerReadings.get(ownerKey);
+      const watched = tracks.get(
+        refKey({ kind: "agent", workstream: ownerRef.workstreamName, id: ownerRef.name })
+      );
+      const settleOwed = watched !== void 0 && // the settle is in hand but not delivered yet: under --first it goes first, the stall
+      // (if the task is still open after its CLOSE block) is the NEXT wait's news. Under --all
+      // a settle is no target and is never delivered before the end: its CLOSE is already
+      // applied (settle()), so a task it left open (a malformed block) is a stall NOW.
+      (!all && watched.latched?.kind === "settled" || watched.latched === void 0 && (watched.handle !== void 0 || watched.needWatch) && r?.runs !== void 0 && (watched.baseline ?? 0) < r.runs);
+      const age = settleOwed ? null : stallAgeMs(ownerKey, r);
+      if (age !== null && r !== void 0) {
+        const token = [
+          row.workstreamId,
+          row.name,
+          ownerKey,
+          r.incarnation ?? "",
+          r.runs ?? "",
+          r.since ?? ""
+        ].join("|");
+        markStall(item, {
+          token,
+          owner: r,
+          ownerRef,
+          ageSecs: Math.round(age / 1e3),
+          // The owner's settled run was refused its CLOSE (a malformed block): say why on the task.
+          ...watched?.close?.applied === false ? { close: watched.close } : {}
+        });
+        if (!stallEmitted.has(token)) {
+          stallEmitted.add(token);
+          const identity = {
+            agentId: r.agentId ?? taskOwnerRowId(db, ref),
+            incarnation: `${r.incarnation ?? ""}${r.runs === void 0 ? `|since:${r.since ?? ""}` : ""}`,
+            runs: r.runs ?? 0
+          };
+          logStallOnce(
+            db,
+            ref,
+            identity,
+            () => emitEvent(
+              db,
+              ref.workstream,
+              "agent.stall",
+              `agent stalled ${ownerRef.name} owns ${ref.id} for ${Math.round(age / 1e3)}s`,
+              ownerRef.name
+            )
+          );
+        }
+        return item;
+      }
+    }
+    if (status !== want) return item;
+    if (matcher !== void 0) {
+      const rep = db.prepare(
+        `SELECT n.content FROM task_notes n JOIN tasks t ON t.id = n.task_id
+             JOIN workstreams w ON w.id = t.workstream_id
+            WHERE w.name = ? AND t.local_id = ? AND n.kind = 'report' ORDER BY n.id DESC LIMIT 1`
+      ).get(ref.workstream, ref.id);
+      if (row.substate !== "done" || rep === void 0 || !matcher.test(rep.content)) return item;
+    }
+    const note = db.prepare(
+      `SELECT COALESCE(MAX(n.id), 0) AS n FROM task_notes n JOIN tasks t ON t.id = n.task_id
+           JOIN workstreams w ON w.id = t.workstream_id WHERE w.name = ? AND t.local_id = ?`
+    ).get(ref.workstream, ref.id);
+    snap.fired = true;
+    item.kind = "closed";
+    item.done = true;
+    item.token = closedToken(note.n);
+    return item;
+  };
+  const agentItem = (t, isTarget, order) => {
+    const l = t.latched;
+    const r = l?.reading;
+    const key = refKey(t.ref);
+    let token;
+    let ckey;
+    let death;
+    if (l?.kind === "settled" && r?.runs !== void 0) {
+      token = { incarnation: r.incarnation ?? "", runs: r.runs };
+    } else if (l?.kind === "input" && r !== void 0) {
+      ckey = urgentKey("input", key);
+      token = inputToken(r);
+    } else if (l?.kind === "dead") {
+      ckey = urgentKey("dead", key);
+      const rowId = agentRowId(db, t.ref);
+      token = { incarnation: `dead:${rowId}`, runs: 1 };
+      death = { rowId: rowId || (r?.agentId ?? 0), name: t.ref.id, workstream: t.ref.workstream };
+    } else if (l?.kind === "exited") {
+      token = { incarnation: `exited:${agentRowId(db, t.ref)}`, runs: 1 };
+    }
+    return {
+      key,
+      ref: t.ref,
+      snap: agentSnapshot(t),
+      target: isTarget,
+      suppressible: !t.explicit,
+      order,
+      done: l?.kind === "settled" || l?.kind === "pane-text" || l?.kind === "dead" || l?.kind === "exited",
+      ready: false,
+      ...l !== void 0 ? { kind: l.kind } : {},
+      ...token !== void 0 ? { token } : {},
+      ...ckey !== void 0 ? { ckey } : {},
+      ...death !== void 0 ? { death } : {}
+    };
+  };
+  const OPEN_TOKEN = { incarnation: "open", runs: 1 };
+  const markOpen = (okey) => {
+    if (cursorOf(okey) !== void 0) return;
+    const owner = ownerOf(okey);
+    if (owner === void 0) return;
+    recordCursors(db, owner, [{ key: okey, token: OPEN_TOKEN }]);
+    cursorsBy.get(owner)?.set(okey, OPEN_TOKEN);
+  };
+  let tally;
+  const evaluate = () => {
+    const items = [];
+    const byKey = /* @__PURE__ */ new Map();
+    let order = 0;
+    const push = (it) => {
+      const prev = byKey.get(it.key);
+      if (prev !== void 0) {
+        prev.target ||= it.target;
+        prev.suppressible &&= it.suppressible;
+        return;
+      }
+      byKey.set(it.key, it);
+      items.push(it);
+    };
+    const owned = ownedRefs();
+    const calls = /* @__PURE__ */ new Map();
+    const addCall = (c, isTarget, suppressible) => {
+      if (c === void 0 || c.state === "refused") return;
+      const prev = calls.get(c.callId);
+      calls.set(c.callId, {
+        call: c,
+        target: (prev?.target ?? false) || isTarget,
+        suppressible: (prev?.suppressible ?? true) && suppressible
+      });
+    };
+    for (const r of input) {
+      if (r.kind === "task") push(taskItem(r, target, true, false, order++));
+      else if (r.kind === "agent") push(agentItem(track(r, true), true, order++));
+      else addCall(getDelegateCall(db, r.id), true, false);
+    }
+    if (opts.wave !== void 0) {
+      const waveCalls = listDelegatesOf(db, callers, opts.wave.workstream, {
+        wave: opts.wave.name
+      });
+      for (const c of waveCalls) addCall(c, true, !all);
+      tally = tallyCalls(waveCalls);
+    }
+    for (const r of owned) {
+      if (r.kind !== "delegate") continue;
+      const c = getDelegateCall(db, r.id);
+      if (c !== void 0 && callInScope(c)) addCall(c, false, true);
+    }
+    if (consumes) {
+      for (const c of listDelegatesOf(db, callers)) {
+        if (!callInScope(c)) continue;
+        addCall(c, false, true);
+        ownerOfKey.set(
+          refKey({ kind: "delegate", workstream: c.workstream, id: c.callId }),
+          c.caller
+        );
+      }
+    }
+    for (const { call, target: isTarget, suppressible } of calls.values()) {
+      push(delegateItem(call, isTarget, suppressible, order++));
+    }
+    if (opts.blockersOf !== void 0 && umbrella !== void 0 && umbrella !== null) {
+      const rows = openBlockers(db, umbrella);
+      let open = false;
+      let readyBlocker = false;
+      for (const b of rows) {
+        const ref = { kind: "task", workstream: b.ws, id: b.id };
+        const it = taskItem(ref, "CLOSED", true, !all, order++);
+        const okey = urgentKey("open", it.key);
+        if (!it.done) {
+          open = true;
+          if (consumes) markOpen(okey);
+          else openLocal.add(it.key);
+        } else if (!all && !(consumes ? cursorOf(okey) !== void 0 : openLocal.has(it.key))) {
+          it.suppressible = true;
+          it.token = void 0;
+          it.kind = void 0;
+        } else if (it.token === void 0 || !isConsumed(cursorOf(it.key), it.token)) {
+          readyBlocker = true;
+        }
+        push(it);
+      }
+      if (!open && !readyBlocker) {
+        const ref = { kind: "task", ...opts.blockersOf };
+        push({
+          key: `blockers:${refKey(ref)}`,
+          ref,
+          snap: { ref, status: "CLOSED", fired: true, dead: false },
+          target: true,
+          suppressible: false,
+          order: order++,
+          kind: "closed",
+          done: true,
+          ready: false,
+          // A state ("nothing is left to wait on"), never news: behind every real event.
+          seen: true
+        });
+      }
+    }
+    for (const r of owned) {
+      if (r.kind === "task") push(taskItem(r, target, false, true, order++));
+    }
+    for (const r of owned) {
+      if (r.kind === "agent") push(agentItem(track(r, false), false, order++));
+    }
+    for (const it of items) {
+      if (it.ref.kind !== "task") continue;
+      const owner = it.snap.owner ?? null;
+      const before = priorTask.get(it.key);
+      const keep = owner === null && it.snap.status === "OPEN" ? before : void 0;
+      priorTask.set(it.key, {
+        status: it.snap.status ?? "OPEN",
+        owner: owner ?? keep?.owner ?? null,
+        ownerWs: it.snap.ownerWorkstream ?? keep?.ownerWs ?? it.ref.workstream,
+        ownerId: owner === null ? keep?.ownerId ?? 0 : taskOwnerRowId(db, it.ref)
+      });
+    }
+    const shown = [];
+    for (const it of items) {
+      const consumed = it.token !== void 0 && isConsumed(cursorOf(it.ckey ?? it.key), it.token);
+      it.seen ||= consumed;
+      const hidden = it.suppressible && consumed;
+      it.hidden = hidden;
+      it.ready = it.kind !== void 0 && !hidden;
+      const urgent = it.kind === "input" || it.kind === "stall" || it.kind === "dead";
+      if (hidden && urgent) it.done = false;
+      if (hidden && !it.target && !urgent) continue;
+      shown.push(it);
+    }
+    return shown;
+  };
+  const driveStalls = (items) => {
+    const handler = opts.handleStall;
+    for (const st of stallStates.values()) {
+      if (st.job !== void 0 || st.result?.disposition !== "return" || st.carry === void 0) {
+        continue;
+      }
+      const { key, stall } = st.carry;
+      const gone = items.find((i) => i.key === key && i.kind !== "stall");
+      if (gone !== void 0 && stall !== void 0) {
+        markStall(gone, stall);
+        gone.hidden = false;
+      }
+    }
+    for (const it of items) {
+      if (it.stall === void 0 || it.kind !== "stall" || it.hidden === true) continue;
+      if (opts.onStall === "warn") {
+        it.ready = false;
+        continue;
+      }
+      const steering = opts.onStall === "steer" || opts.onStall === "release";
+      const caller = ownerOf(it.key);
+      if (!steering || handler === void 0 || caller === void 0) {
+        it.ready = true;
+        continue;
+      }
+      const { token, owner, ownerRef } = it.stall;
+      let st = stallStates.get(token);
+      if (st === void 0) {
+        const own = db.prepare(
+          `SELECT a.id, a.pane_id FROM agents a JOIN workstreams w ON w.id = a.workstream_id
+              WHERE a.name = ? AND w.name = ?`
+        ).get(ownerRef.name, ownerRef.workstreamName);
+        const taskId = taskIdFor(db, it.ref.id, it.ref.workstream);
+        if (own === void 0 || taskId === null) {
+          it.ready = true;
+          continue;
+        }
+        const ctx = {
+          caller,
+          generation: begun.get(caller)?.generation ?? null,
+          ref: it.ref,
+          taskId,
+          revision: taskRevision(db, it.ref.workstream, it.ref.id),
+          owner: {
+            workstream: ownerRef.workstreamName,
+            name: ownerRef.name,
+            agentId: owner.agentId ?? own.id,
+            paneId: owner.paneId ?? own.pane_id,
+            status: owner.status,
+            source: owner.source ?? "none",
+            since: owner.since ?? null,
+            settled: false,
+            ...owner.ctl !== void 0 ? { ctl: owner.ctl } : {},
+            ...owner.incarnation !== void 0 ? { incarnation: owner.incarnation } : {},
+            ...owner.runs !== void 0 ? { runs: owner.runs } : {},
+            ...owner.pending !== void 0 ? { pending: owner.pending } : {},
+            ...owner.reason !== void 0 ? { reason: owner.reason } : {}
+          },
+          stallToken: token,
+          deadlineMs: Number.isFinite(deadline) ? Math.max(0, deadline - Date.now()) : Number.MAX_SAFE_INTEGER,
+          signal: watchAbort.signal
+        };
+        const fresh = {};
+        const action = opts.onStall === "release" ? "release" : "steer";
+        fresh.job = Promise.resolve().then(() => handler(ctx)).catch(
+          (e) => ({
+            disposition: "return",
+            action,
+            state: "unknown",
+            reason: e instanceof Error ? e.message : String(e)
+          })
+        ).then((res) => {
+          fresh.result = res;
+          fresh.job = void 0;
+          const t = tracks.get(
+            refKey({
+              kind: "agent",
+              ...{ workstream: ownerRef.workstreamName, id: ownerRef.name }
+            })
+          );
+          if (t !== void 0 && res.afterRuns !== void 0) {
+            if (t.latched?.kind === "settled") rearm(t, res.afterRuns);
+            else if (t.latched === void 0) {
+              t.baseline = res.afterRuns;
+              t.wasBusy = false;
+            }
+          }
+          wake();
+        });
+        fresh.carry = { key: it.key, stall: it.stall };
+        st = fresh;
+        stallStates.set(token, st);
+      }
+      it.ready = st.job === void 0 && st.result?.disposition === "return";
+    }
+  };
+  const select2 = (items) => {
+    const rank = (a, b) => (
+      // Never-returned events first: an event that was already returned once (an
+      // unchanged dialog, a dead pane, a stall) never outranks one that was not.
+      Number(a.seen === true) - Number(b.seen === true) || urgency(a.kind) - urgency(b.kind) || // Under --all a failed gate is the firing event, so its code is the exit.
+      Number(failedGate(b)) - Number(failedGate(a)) || Number(b.target) - Number(a.target) || a.order - b.order
+    );
+    const ready = items.filter((i) => i.ready).sort(rank);
+    if (!all) {
+      const best2 = ready[0];
+      if (best2 === void 0) return void 0;
+      const same = (a, b) => a.kind === "settled" && a.ref.kind === "agent" && a.snap.close?.applied === true && a.snap.close.task === b.ref.id && a.ref.workstream === b.ref.workstream && b.ref.kind === "task" && b.kind === "closed";
+      const companions = ready.filter(
+        (i) => i !== best2 && (same(i, best2) || same(best2, i) || sameDeath(i, best2))
+      );
+      return { event: best2, fired: [best2, ...companions] };
+    }
+    const urgent = ready.find(
+      (i) => i.kind === "input" || i.kind === "stall" || !i.target && (i.kind === "dead" || i.kind === "delegate")
+    );
+    if (urgent !== void 0) {
+      const companions = ready.filter((i) => i !== urgent && sameDeath(i, urgent));
+      return { event: urgent, fired: [urgent, ...companions] };
+    }
+    const targets = items.some((i) => i.target) ? items.filter((i) => i.target) : items;
+    if (targets.length === 0 || !targets.every((i) => i.done)) return void 0;
+    const sorted = [...targets].sort(rank);
+    const best = sorted.find((i) => i.ready) ?? sorted[0];
+    return best === void 0 ? void 0 : { event: best, fired: targets.filter((i) => i.done) };
+  };
+  const build = (kind, items, chosen, drained = false) => {
+    const e = chosen?.event;
+    for (const f of chosen?.fired ?? []) delivered.push(f);
+    return {
+      event: {
+        kind,
+        ref: e?.ref ?? null,
+        ...e?.snap.incarnation !== void 0 ? { incarnation: e.snap.incarnation } : {},
+        ...e?.snap.runs !== void 0 ? { runs: e.snap.runs } : {}
+      },
+      refs: snapshotsOf(items, chosen?.fired ?? []),
+      delivered: (chosen?.fired ?? []).filter(isCompletion).map((i) => i.ref),
+      timedOut: kind === "heartbeat" && !drained,
+      interrupted: kind === "interrupted",
+      exit: exitFor(kind) !== 0 ? exitFor(kind) : (chosen?.fired ?? []).find(failedGate)?.snap.exit ?? 0,
+      cursor: {},
+      ...e?.stall !== void 0 && stallStates.get(e.stall.token)?.result !== void 0 ? { action: stallStates.get(e.stall.token)?.result } : {},
+      humanNeeds: callers.flatMap((c) => openHumanNeeds(db, c)),
+      sinceSeq,
+      ...tally !== void 0 ? { tally } : {},
+      ...drained ? { drained: true } : {}
+    };
+  };
+  const rethrow = () => {
+    if (fatal === void 0) return;
+    watchAbort.abort();
+    throw fatal.error;
+  };
+  let committed = false;
+  let applied = true;
+  const commit = (event) => {
+    if (!consumes) return true;
+    const ok = db.transaction(() => {
+      for (const c of callers) cursorsBy.set(c, readCursors(db, c));
+      if (
+        // Only news this wait saw as unconsumed can turn stale; the re-read hides it next time.
+        event?.token !== void 0 && event.ready && event.suppressible && isConsumed(cursorOf(event.ckey ?? event.key), event.token)
+      ) {
+        return false;
+      }
+      const completed = delivered.filter(isCompletion);
+      for (const c of callers) {
+        const mine = completed.filter((i) => ownerOf(i.key) === c);
+        const tokens = delivered.filter((i) => i.token !== void 0 && ownerOf(i.ckey ?? i.key) === c).flatMap(
+          (i) => i.token === void 0 ? [] : [{ key: i.ckey ?? i.key, token: i.token }]
+        );
+        const b = begun.get(c);
+        if (b !== void 0) {
+          const ended = endWait(
+            db,
+            c,
+            b.generation,
+            mine.map((i) => ({
+              ...registered(i.ref),
+              ...i.kind === "settled" && i.snap.runs !== void 0 ? {
+                runs: i.snap.runs,
+                ...i.snap.incarnation !== void 0 ? { incarnation: i.snap.incarnation } : {}
+              } : {}
+            }))
+          );
+          if (!ended.applied) {
+            applied = false;
+            continue;
+          }
+        }
+        recordCursors(db, c, tokens);
+      }
+      return true;
+    }).immediate();
+    if (ok) committed = true;
+    else delivered.length = 0;
+    return ok;
+  };
+  let result;
+  try {
+    for (; ; ) {
+      if (stopReason === "abort") {
+        result = build("interrupted", evaluate());
+        break;
+      }
+      if (stopReason === "deadline" || Date.now() >= deadline) {
+        const items2 = evaluate();
+        driveStalls(items2);
+        const chosen2 = select2(items2);
+        const r = chosen2 ? build(chosen2.event.kind ?? "closed", items2, chosen2) : build("heartbeat", items2);
+        if (!commit(chosen2?.event)) continue;
+        result = r;
+        break;
+      }
+      await refresh();
+      rethrow();
+      if (stopReason === "abort") continue;
+      const items = evaluate();
+      driveStalls(items);
+      opts.onPicture?.(items.map((i) => i.snap));
+      if (items.length === 0) throw new WaitNothingError();
+      const chosen = select2(items);
+      if (chosen !== void 0) {
+        const r = build(chosen.event.kind ?? "closed", items, chosen);
+        if (!commit(chosen.event)) continue;
+        result = r;
+        break;
+      }
+      if (!all && items.every((i) => i.done)) {
+        result = build("heartbeat", items, void 0, true);
+        break;
+      }
+      if (stopReason !== void 0) continue;
+      const polled = watchDeaths || observeOwners || items.some((i) => i.ref.kind !== "agent") || [...tracks.values()].some((t) => t.latched === void 0 && t.handle === void 0);
+      const left = deadline - Date.now();
+      const ms = polled ? Math.min(pollMs, left) : left;
+      if (ms <= 0) continue;
+      let timer;
+      const sleeper = opts.sleep ?? sleepSeam;
+      const slept = !polled ? new Promise(() => {
+      }) : sleeper ? sleeper(ms) : new Promise((resolve4) => {
+        timer = setTimeout(resolve4, ms);
+      });
+      await Promise.race([woken, slept, stopP]);
+      clearTimeout(timer);
+      woken = new Promise((resolve4) => {
+        wake = resolve4;
+      });
+      rethrow();
+    }
+  } finally {
+    clearTimeout(deadlineTimer);
+    opts.signal?.removeEventListener("abort", onAbort);
+    watchAbort.abort();
+    if (consumes) {
+      if (!committed) commit();
+      if (result !== void 0) {
+        result.cursor = Object.fromEntries(callers.flatMap((c) => [...readCursors(db, c)]));
+        if (!applied) result.superseded = true;
+      }
+    } else if (result !== void 0) result.cursor = {};
+    if (opts.sync !== false) await ambientFlush(db, { quiet: true });
+  }
+  return result;
+}
+
+// src/wait-action-receipts.ts
+var fromRaw = (r) => ({
+  taskId: r.task_id,
+  ownerId: r.owner_id,
+  incarnation: r.incarnation,
+  action: r.action,
+  caller: r.caller,
+  taskRef: r.task_ref,
+  ownerRef: r.owner_ref,
+  paneId: r.pane_id,
+  previewRevision: r.preview_revision,
+  msgId: r.msg_id,
+  state: r.state,
+  runs: r.runs,
+  detail: r.detail,
+  createdAt: r.created_at,
+  updatedAt: r.updated_at
+});
+var EDGES = {
+  reserved: ["sending", "refused", "released"],
+  sending: ["sent", "unknown", "refused"],
+  unknown: ["sent"],
+  sent: [],
+  refused: [],
+  released: []
+};
+function getActionReceipt(db, key) {
+  const row = db.prepare(
+    `SELECT * FROM wait_action_receipts
+        WHERE task_id = ? AND owner_id = ? AND incarnation = ? AND action = ?`
+  ).get(key.taskId, key.ownerId, key.incarnation, key.action);
+  return row === void 0 ? void 0 : fromRaw(row);
+}
+function reserveActionReceipt(db, key, info) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const res = db.prepare(
+    `INSERT OR IGNORE INTO wait_action_receipts
+         (task_id, owner_id, incarnation, action, caller, task_ref, owner_ref, pane_id,
+          preview_revision, msg_id, state, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'reserved', ?, ?)`
+  ).run(
+    key.taskId,
+    key.ownerId,
+    key.incarnation,
+    key.action,
+    info.caller,
+    info.taskRef,
+    info.ownerRef,
+    info.paneId,
+    info.previewRevision,
+    info.msgId ?? null,
+    now,
+    now
+  );
+  const receipt = getActionReceipt(db, key);
+  if (receipt === void 0) throw new Error("wait action receipt vanished after reservation");
+  return { created: res.changes === 1, receipt };
+}
+function transitionActionReceipt(db, key, from, to, patch = {}) {
+  if (!EDGES[from].includes(to)) {
+    throw new Error(`wait action receipt: illegal transition ${from} -> ${to}`);
+  }
+  const res = db.prepare(
+    `UPDATE wait_action_receipts
+          SET state = ?, msg_id = COALESCE(?, msg_id), runs = COALESCE(?, runs),
+              detail = COALESCE(?, detail), updated_at = ?
+        WHERE task_id = ? AND owner_id = ? AND incarnation = ? AND action = ? AND state = ?`
+  ).run(
+    to,
+    patch.msgId ?? null,
+    patch.runs ?? null,
+    patch.detail ?? null,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    key.taskId,
+    key.ownerId,
+    key.incarnation,
+    key.action,
+    from
+  );
+  return res.changes === 1;
+}
+
+// src/wait-actions.ts
+var refused = (reason, action) => ({
+  disposition: "return",
+  action,
+  state: "refused",
+  reason
+});
+function guardStall(db, ctx, callers, action) {
+  const no2 = (reason) => ({ ok: false, reason });
+  if (ctx.signal.aborted) return no2("the wait was aborted");
+  if (!callers.includes(ctx.caller)) {
+    return no2(`caller ${ctx.caller} is not one of this process's callers`);
+  }
+  if (ctx.generation !== null) {
+    const reg = readWaitRegistration(db, ctx.caller);
+    if (reg === void 0 || reg.generation !== ctx.generation) {
+      return no2("the wait was superseded (generation changed)");
+    }
+  }
+  const task = db.prepare(
+    `SELECT t.local_id, w.name AS workstream, t.status, t.kind, t.owner_id
+         FROM tasks t JOIN workstreams w ON w.id = t.workstream_id WHERE t.id = ?`
+  ).get(ctx.taskId);
+  if (task === void 0) return no2("the task no longer exists");
+  if (task.local_id !== ctx.ref.id || task.workstream !== ctx.ref.workstream) {
+    return no2("the ref does not name this task");
+  }
+  if (task.kind !== "work") return no2(`a ${task.kind} task is never ${action}d`);
+  if (task.status !== "IN_PROGRESS") return no2(`the task is ${task.status}, not IN_PROGRESS`);
+  if (task.owner_id === null || task.owner_id !== ctx.owner.agentId) {
+    return no2("the task's owner is no longer the stalled agent");
+  }
+  const agent = db.prepare("SELECT a.name, a.pane_id, a.spawner FROM agents a WHERE a.id = ?").get(task.owner_id);
+  if (agent === void 0) return no2("the owner is no longer registered");
+  if (agent.pane_id !== ctx.owner.paneId) return no2("the owner's pane changed (pane mismatch)");
+  if (agent.spawner === null || !callers.includes(agent.spawner)) {
+    return no2("the owner was not spawned by this caller (not yours to act on)");
+  }
+  if (action === "steer") {
+    if (ctx.owner.status !== "needs_input" || ctx.owner.ctl !== "ok") {
+      return no2(`the owner is not idle on a healthy control socket (state ${ctx.owner.status})`);
+    }
+    if (ctx.owner.incarnation === void 0 || ctx.owner.incarnation === "") {
+      return no2("the owner's pi named no incarnation: a steer could not be bound to it");
+    }
+  } else {
+    const brokenCtl = ctx.owner.ctl === "missing" || ctx.owner.ctl === "refused";
+    const needsAttention = ctx.owner.status === "needs_input" || brokenCtl && (ctx.owner.status === "unknown" || ctx.owner.status === "busy");
+    if (!needsAttention) {
+      return no2(`the owner is not waiting on anyone (runtime state ${ctx.owner.status})`);
+    }
+  }
+  if (!autoPermitted(db, ctx.taskId)) {
+    return no2("the task is not permitted for auto action on this machine (mu task auto)");
+  }
+  if (callers.some((c) => openHumanNeeds(db, c).length > 0)) {
+    return no2("a human stop is open for this caller: leave the stall to the human");
+  }
+  const revision = taskRevision(db, task.workstream, task.local_id);
+  if (revision !== ctx.revision) {
+    return no2(
+      `the task changed since the stall was seen (revision ${ctx.revision} -> ${revision})`
+    );
+  }
+  return {
+    ok: true,
+    found: {
+      localId: task.local_id,
+      workstream: task.workstream,
+      ownerId: task.owner_id,
+      ownerName: agent.name,
+      paneId: agent.pane_id
+    }
+  };
+}
+var keyOf = (ctx, ownerId, action) => ({
+  taskId: ctx.taskId,
+  ownerId,
+  incarnation: ctx.owner.incarnation ?? "",
+  action
+});
+var infoOf = (ctx, f) => ({
+  caller: ctx.caller,
+  taskRef: `${f.workstream}/${f.localId}`,
+  ownerRef: `${ctx.owner.workstream}/${f.ownerName}`,
+  paneId: f.paneId,
+  previewRevision: ctx.revision
+});
+function releaseBody(db, ctx, callers) {
+  const g = guardStall(db, ctx, callers, "release");
+  if (!g.ok) return refused(g.reason, "release");
+  const { found } = g;
+  const key = keyOf(ctx, found.ownerId, "release");
+  if (getActionReceipt(db, key) !== void 0) {
+    return {
+      disposition: "return",
+      action: "release",
+      state: "budget-exhausted",
+      reason: "this owner incarnation was already released once for this task"
+    };
+  }
+  const res = releaseTask(db, found.localId, {
+    workstream: found.workstream,
+    expectedOwnerId: found.ownerId,
+    ifRevision: ctx.revision,
+    author: ctx.caller,
+    evidence: `stall: ${found.ownerName} needed attention (stall ${ctx.stallToken}); released for another worker`
+  });
+  if (!res.changed) return refused("the release changed nothing", "release");
+  reserveActionReceipt(db, key, infoOf(ctx, found));
+  transitionActionReceipt(db, key, "reserved", "released", {
+    detail: `released from ${found.ownerName}`
+  });
+  return {
+    disposition: "return",
+    action: "release",
+    state: "released",
+    ...ctx.owner.incarnation !== void 0 ? { incarnation: ctx.owner.incarnation } : {},
+    reason: `released ${found.localId} from ${found.ownerName}`
+  };
+}
+async function releaseStall(db, ctx, opts = {}) {
+  const callers = opts.callers ?? currentCallers();
+  try {
+    return withOpContext(
+      db,
+      { intent: "task.release", actor: ctx.caller, group: "new" },
+      () => releaseBody(db, ctx, callers)
+    );
+  } catch (e) {
+    return refused(
+      `release failed, nothing changed: ${e instanceof Error ? e.message : String(e)}`,
+      "release"
+    );
+  }
+}
+function releaseStallHandler(db, opts = {}) {
+  return (ctx) => releaseStall(db, ctx, opts);
+}
+function steerText(workstream, taskId) {
+  return `[mu] ${workstream}/${taskId} is still yours (IN_PROGRESS) and mu is waiting on it. If the work is done and verified, close it: mu task close ${taskId} -w ${workstream} --evidence "<what you verified>". If you are blocked or need an answer, say so in one line and stop.`;
+}
+var steerResult = (state, disposition, extra = {}) => ({ disposition, action: "steer", state, ...extra });
+function planSteer(db, ctx, callers) {
+  return db.transaction(() => {
+    const key = keyOf(ctx, ctx.owner.agentId, "steer");
+    const have = getActionReceipt(db, key);
+    if (have !== void 0 && have.state !== "reserved") {
+      if (have.state === "sending" || have.state === "unknown") {
+        if (have.msgId === null) {
+          return {
+            kind: "done",
+            result: steerResult("unknown", "return", {
+              reason: "a steer may have been written but its id was lost: not resent"
+            })
+          };
+        }
+        return {
+          kind: "probe",
+          msgId: have.msgId,
+          key,
+          paneId: have.paneId,
+          state: have.state
+        };
+      }
+      return {
+        kind: "done",
+        result: steerResult(have.state === "refused" ? "refused" : "budget-exhausted", "return", {
+          reason: have.state === "refused" ? `pi refused the steer for this owner incarnation (${have.detail ?? "no reason"}); not retried` : "this owner incarnation was already nudged once for this task",
+          ...have.msgId !== null ? { msgId: have.msgId } : {}
+        })
+      };
+    }
+    const g = guardStall(db, ctx, callers, "steer");
+    if (!g.ok) return { kind: "done", result: refused(g.reason, "steer") };
+    const msgId = have?.msgId ?? newMsgId();
+    if (have === void 0) {
+      reserveActionReceipt(db, key, { ...infoOf(ctx, g.found), msgId });
+    }
+    return { kind: "send", msgId, key, found: g.found };
+  }).immediate();
+}
+async function probeSteer(db, ctx, plan, timeoutMs) {
+  const unknown = (reason) => {
+    if (plan.state === "sending") {
+      try {
+        transitionActionReceipt(db, plan.key, "sending", "unknown", { detail: reason });
+      } catch {
+      }
+    }
+    return steerResult("unknown", "return", { msgId: plan.msgId, reason });
+  };
+  const agent = getAgent(db, ctx.owner.name, ctx.owner.workstream);
+  if (agent === void 0 || agent.incarnation !== plan.key.ownerId || agent.paneId !== plan.paneId) {
+    return unknown("the owner was replaced: the earlier steer cannot be confirmed (not resent)");
+  }
+  if (ctx.signal.aborted) return unknown("the wait was aborted before the receipt probe");
+  const check = await checkMessage(agentCtlSocket(db, agent), plan.msgId, timeoutMs);
+  if (check.state !== "accepted" || check.incarnation !== plan.key.incarnation) {
+    return unknown(
+      check.state === "accepted" ? "the receipt came from another pi incarnation: not confirmed" : "the earlier steer is not confirmed (receipt absent or unreachable): not resent"
+    );
+  }
+  try {
+    transitionActionReceipt(db, plan.key, plan.state, "sent", {
+      ...check.runs !== void 0 ? { runs: check.runs } : {},
+      detail: "confirmed by receipt probe"
+    });
+  } catch {
+  }
+  if (check.runs !== void 0 && ctx.owner.runs !== void 0 && check.runs < ctx.owner.runs) {
+    return steerResult("sent", "return", {
+      msgId: plan.msgId,
+      incarnation: plan.key.incarnation,
+      afterRuns: check.runs,
+      reason: "nudged earlier, owner idle again"
+    });
+  }
+  return sentResult(plan.msgId, plan.key.incarnation, check.runs);
+}
+function sentResult(msgId, incarnation, runs) {
+  return steerResult("sent", runs === void 0 ? "return" : "continue", {
+    msgId,
+    incarnation,
+    ...runs !== void 0 ? { afterRuns: runs } : {},
+    ...runs === void 0 ? { reason: "sent, but pi reported no run baseline to wait from" } : {}
+  });
+}
+async function steerStall(db, ctx, opts = {}) {
+  const callers = opts.callers ?? currentCallers();
+  const timeoutMs = Math.min(CTL_DEFAULT_TIMEOUT_MS, Math.max(1, ctx.deadlineMs));
+  let plan;
+  try {
+    plan = planSteer(db, ctx, callers);
+  } catch (e) {
+    return refused(`steer failed, nothing sent: ${errText(e)}`, "steer");
+  }
+  if (plan.kind === "done") return plan.result;
+  if (plan.kind === "probe") return probeSteer(db, ctx, plan, timeoutMs);
+  const { key, msgId, found } = plan;
+  const agent = getAgent(db, found.ownerName, ctx.owner.workstream);
+  if (agent === void 0 || agent.incarnation !== found.ownerId) {
+    return refused("the owner is no longer registered", "steer");
+  }
+  let won = false;
+  let vetoed;
+  const beforeWrite = () => {
+    const go = db.transaction(() => {
+      const g = guardStall(db, ctx, callers, "steer");
+      if (!g.ok) {
+        vetoed = refused(g.reason, "steer");
+        return false;
+      }
+      if (!transitionActionReceipt(db, key, "reserved", "sending", { msgId })) {
+        vetoed = steerResult("budget-exhausted", "return", {
+          reason: "another waiter owns this nudge"
+        });
+        return false;
+      }
+      return true;
+    }).immediate();
+    won = go;
+    return go;
+  };
+  try {
+    const sent = await sendViaTransport(agent, steerText(found.workstream, found.localId), {
+      socket: agentCtlSocket(db, agent),
+      mode: "steer",
+      msgId,
+      expectIncarnation: key.incarnation,
+      ctlGuard: { signal: ctx.signal, timeoutMs, beforeWrite }
+    });
+    try {
+      const patch = {
+        ...sent.runs !== void 0 ? { runs: sent.runs } : {},
+        detail: sent.receipt ?? "accepted"
+      };
+      if (!transitionActionReceipt(db, key, "sending", "sent", patch)) {
+        transitionActionReceipt(db, key, "unknown", "sent", patch);
+      }
+      recordSend(
+        db,
+        agent,
+        "steer",
+        Buffer.byteLength(steerText(found.workstream, found.localId)),
+        {
+          transport: "ctl",
+          state: sent.state
+        },
+        ctx.caller
+      );
+    } catch {
+    }
+    return sentResult(msgId, key.incarnation, sent.runs);
+  } catch (e) {
+    if (e instanceof CtlWriteVetoedError || !won) {
+      return vetoed ?? refused(`steer not sent: ${errText(e)}`, "steer");
+    }
+    const definite = e instanceof AgentSendRefusedError || e instanceof AgentReplacedError;
+    const to = definite ? "refused" : "unknown";
+    try {
+      transitionActionReceipt(db, key, "sending", to, { detail: errText(e) });
+    } catch {
+    }
+    return steerResult(to, "return", { msgId, reason: errText(e) });
+  }
+}
+var errText = (e) => e instanceof Error ? e.message : String(e);
+function steerStallHandler(db, opts = {}) {
+  return (ctx) => steerStall(db, ctx, opts);
+}
+function waitWithActions(db, refs, opts) {
+  if (opts.handleStall !== void 0) return waitForEvents(db, refs, opts);
+  const actionOpts = { callers: opts.callers };
+  const handleStall = opts.onStall === "steer" ? steerStallHandler(db, actionOpts) : opts.onStall === "release" ? releaseStallHandler(db, actionOpts) : void 0;
+  return waitForEvents(db, refs, handleStall === void 0 ? opts : { ...opts, handleStall });
+}
+
+// src/wait-ctl.ts
+function ctlAgentHooks(db, opts = {}) {
+  return {
+    readAgents: async (refs) => {
+      const agents = refs.flatMap((r) => {
+        const a = getAgent(db, r.id, r.workstream);
+        return a === void 0 ? [] : [a];
+      });
+      const observed = await observeAgentStates(db, agents);
+      if (opts.paneText !== true) return observed;
+      const out = new Map(observed);
+      for (const a of agents) {
+        const key = `${a.workstreamName}/${a.name}`;
+        const base = out.get(key);
+        if (base === void 0 || base.status === null) continue;
+        if (base.ctl === "ok") continue;
+        try {
+          const text = await (await activeMux()).capture(a.paneId, { lines: 200 });
+          out.set(key, { ...base, lastText: text.slice(-WAIT_TEXT_MAX), textSource: "pane" });
+        } catch {
+        }
+      }
+      return out;
+    },
+    watchAgent: async (ref, signal, ctx) => {
+      const agent = getAgent(db, ref.id, ref.workstream);
+      if (agent === void 0) return void 0;
+      const sock = agentCtlSocket(db, agent);
+      let afterRuns = ref.afterRuns;
+      let unknownBaseline;
+      if (afterRuns === void 0 && (ctx.owed || ctx.baseline !== void 0 || ctx.cursor !== void 0)) {
+        if (!expectsCtl(agent, sock)) return void 0;
+        const probe = await ctlProbe(sock);
+        if (probe.kind !== "ok") return void 0;
+        const inc = probe.incarnation;
+        const b = ctx.baseline;
+        const baseOk = b !== void 0 && (b.agentId === void 0 || b.agentId === agent.incarnation) && (b.incarnation === void 0 || inc !== void 0 && b.incarnation === inc);
+        const cursorOk = ctx.cursor !== void 0 && inc !== void 0 && ctx.cursor.incarnation === inc;
+        const fromCursor = cursorOk && ctx.cursor !== void 0 ? ctx.cursor.runs : void 0;
+        if (baseOk && b !== void 0) {
+          afterRuns = Math.max(b.afterRuns, fromCursor ?? 0);
+        } else if (fromCursor !== void 0) afterRuns = fromCursor;
+        else if (ctx.owed) {
+          afterRuns = probe.status.runs;
+          unknownBaseline = {
+            afterRuns,
+            ...inc !== void 0 ? { incarnation: inc } : {},
+            agentId: agent.incarnation
+          };
+        }
+      }
+      const handle = await watchAgentRun(agent, sock, signal, {
+        ...afterRuns !== void 0 ? { afterRuns } : {},
+        ...ref.incarnation !== void 0 ? { inc: ref.incarnation } : {}
+      });
+      return handle !== void 0 && unknownBaseline !== void 0 ? { ...handle, unknownBaseline } : handle;
+    }
+  };
+}
+
+// src/next-recover.ts
+var OBSERVE_MS = 3e3;
+var idleOnCtl = (f) => f.status === "needs_input" && f.ctl === "ok" && f.pending !== true && f.blocked === void 0;
+var workerKey = (a) => `${a.workstreamName}/${a.name}`;
+var observeWorkers = (db) => async (agents, { signal, ms }) => {
+  const states = await observeAgentStates(db, agents);
+  const out = /* @__PURE__ */ new Map();
+  await Promise.all(
+    agents.map(async (agent) => {
+      const key = workerKey(agent);
+      const s = states.get(key);
+      if (s === void 0) return;
+      const facts = {
+        status: s.status,
+        ...s.ctl !== void 0 ? { ctl: s.ctl } : {},
+        ...s.pending !== void 0 ? { pending: s.pending } : {},
+        ...s.blocked !== void 0 ? { blocked: s.blocked } : {},
+        ...s.incarnation !== void 0 ? { incarnation: s.incarnation } : {},
+        ...s.runs !== void 0 ? { runs: s.runs } : {}
+      };
+      out.set(key, facts);
+      const sock = agentCtlSocket(db, agent);
+      if (!idleOnCtl(s) || s.runs === void 0 || s.runs < 1 || !expectsCtl(agent, sock)) return;
+      const stop = new AbortController();
+      const timer = setTimeout(() => stop.abort(), ms);
+      const onAbort = () => stop.abort();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        const watch = await watchAgentRun(agent, sock, stop.signal, {
+          afterRuns: s.runs - 1,
+          ...s.incarnation !== void 0 ? { inc: s.incarnation } : {}
+        });
+        if (watch === void 0) return;
+        const settled = await watch.settled;
+        if (settled.settled) {
+          out.set(key, {
+            ...facts,
+            ...settled.runs !== void 0 ? { runs: settled.runs } : {},
+            ...settled.incarnation !== void 0 ? { incarnation: settled.incarnation } : {},
+            ...settled.lastError !== void 0 ? { lastError: settled.lastError } : {}
+          });
+        }
+      } catch {
+      } finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      }
+    })
+  );
+  return out;
+};
+function inFlightWorkers(db, workstream) {
+  const rows = db.prepare(
+    `SELECT t.id AS id, t.local_id AS local_id
+         FROM task_auto a
+         JOIN tasks t ON t.id = a.task_id
+         JOIN workstreams w ON w.id = t.workstream_id AND w.name = ?
+        WHERE a.enabled = 1 AND t.kind = 'work' AND t.dispatch_host = ?
+          AND t.status = 'IN_PROGRESS' AND t.owner_id IS NOT NULL
+        ORDER BY t.id`
+  ).all(workstream, localMachineId(db));
+  const out = [];
+  for (const r of rows) {
+    if (!autoPermitted(db, r.id)) continue;
+    const delivered = deliveredOf(db, r.id);
+    if (delivered === void 0) continue;
+    const { receipt } = delivered;
+    const id = savedIdentity(db, receipt);
+    if (id.agent === void 0) continue;
+    const owner = db.prepare("SELECT owner_id FROM tasks WHERE id = ?").get(r.id);
+    if (owner.owner_id !== id.agent.incarnation) continue;
+    out.push({
+      task: r.local_id,
+      taskId: r.id,
+      agent: id.agent,
+      runs: receipt.runs,
+      incarnation: receipt.incarnation
+    });
+  }
+  return out;
+}
+function exhaustedAfterDeath(db, workstream) {
+  const rows = db.prepare(
+    `SELECT t.id AS id, t.local_id AS local_id, a.max_runs AS max
+         FROM task_auto a
+         JOIN tasks t ON t.id = a.task_id
+         JOIN workstreams w ON w.id = t.workstream_id AND w.name = ?
+        WHERE a.enabled = 1 AND t.kind = 'work' AND t.dispatch_host = ?
+          AND t.status = 'OPEN' AND a.runs >= a.max_runs
+        ORDER BY t.id`
+  ).all(workstream, localMachineId(db));
+  const out = [];
+  for (const r of rows) {
+    if (!autoPermitted(db, r.id)) continue;
+    const delivered = deliveredOf(db, r.id);
+    if (delivered === void 0) continue;
+    if (savedIdentity(db, delivered.receipt).stale === void 0) continue;
+    out.push({
+      task: r.local_id,
+      reason: `its worker is gone and it used its ${r.max} run(s): raise the ceiling (mu task auto --max) or take it over`
+    });
+  }
+  return out;
+}
+async function scanRecovery(db, workstream, observe, opts = {}) {
+  const workers = inFlightWorkers(db, workstream);
+  const out = [];
+  if (workers.length > 0) {
+    const facts = await observe(
+      workers.map((w) => w.agent),
+      { ...opts.signal !== void 0 ? { signal: opts.signal } : {}, ms: opts.ms ?? OBSERVE_MS }
+    );
+    for (const w of workers) {
+      const f = facts.get(workerKey(w.agent));
+      if (f === void 0) continue;
+      if (f.status === null) {
+        if (w.agent.host !== null) {
+          out.push({
+            kind: "attention",
+            task: w.task,
+            agent: w.agent.name,
+            reason: `remote worker ${w.agent.name} on ${w.agent.host} has no pane: its tree is kept, not reaped (mu agent collect, then close it)`
+          });
+        } else {
+          out.push({
+            kind: "reap",
+            task: w.task,
+            agent: w.agent,
+            why: "its pane is gone"
+          });
+        }
+        continue;
+      }
+      if (f.lastError === void 0) continue;
+      if (!idleOnCtl(f)) continue;
+      const attention = (reason) => {
+        out.push({ kind: "attention", task: w.task, agent: w.agent.name, reason });
+      };
+      if (w.agent.host !== null) {
+        attention(`remote worker ${w.agent.name} stopped on an API error: not retried from here`);
+        continue;
+      }
+      if (f.incarnation === void 0 || f.runs === void 0 || w.runs === null) {
+        attention(
+          `${w.agent.name} stopped on an API error but no run baseline or pi incarnation is known: not retried`
+        );
+        continue;
+      }
+      if (f.runs <= w.runs) continue;
+      const auto = getAutoConfig(db, w.taskId);
+      if (auto !== void 0 && auto.runs >= auto.maxRuns) {
+        attention(
+          `${w.agent.name} stopped on an API error and ${w.task} used its ${auto.maxRuns} run(s): raise the ceiling (mu task auto --max) or take it over`
+        );
+        continue;
+      }
+      out.push({
+        kind: "retry",
+        task: w.task,
+        error: f.lastError,
+        target: {
+          agent: { incarnation: w.agent.incarnation, paneId: w.agent.paneId, name: w.agent.name },
+          pi: f.incarnation,
+          errorRuns: f.runs
+        }
+      });
+    }
+  }
+  return out;
+}
+function liveWorkers(db, workstream) {
+  const row = db.prepare(
+    `SELECT COUNT(*) AS n FROM agents a
+         JOIN workstreams w ON w.id = a.workstream_id AND w.name = ?
+        WHERE EXISTS (SELECT 1 FROM tasks t WHERE t.owner_id = a.id AND t.status = 'IN_PROGRESS')
+           OR EXISTS (SELECT 1 FROM spawn_receipts r JOIN tasks t ON t.id = r.task_id
+                       WHERE r.agent_id = a.id AND r.pane_id = a.pane_id
+                         AND r.attempt_key LIKE 'auto:%'
+                         AND r.state IN ('pane', 'claimed', 'sending', 'unknown')
+                         AND t.status != 'CLOSED')`
+  ).get(workstream);
+  return row.n;
+}
+
+// src/next-refute.ts
+var REFUTE_WORKSTREAM = "scratch";
+var READ_MS = 3e3;
+var CHECK_TIMEOUT_S = 1800;
+var readChecker = async (db, agent, base, { signal, ms }) => {
+  const live = (await observeAgentStates(db, [agent])).get(agentKey(agent));
+  if (live === void 0) return { kind: "running" };
+  if (live.status === null) return { kind: "died" };
+  if (!idleOnCtl(live) || live.runs === void 0 || live.runs <= base.afterRuns) {
+    return { kind: "running" };
+  }
+  const stop = new AbortController();
+  const timer = setTimeout(() => stop.abort(), ms);
+  const onAbort = () => stop.abort();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const watch = await watchAgentRun(agent, agentCtlSocket(db, agent), stop.signal, {
+      afterRuns: base.afterRuns,
+      ...base.inc !== null ? { inc: base.inc } : {}
+    });
+    const done = watch === void 0 ? void 0 : await watch.settled;
+    if (done === void 0 || !done.settled) return { kind: "running" };
+    const outcome = delegateOutcome({ fired: true, dead: false, ...done }, false);
+    return { kind: "answer", outcome, text: done.lastText ?? done.lastError };
+  } catch (err) {
+    if (err instanceof AgentRestartedError) return { kind: "died" };
+    throw err;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+};
+function nextCheck(db, workstream, caller, skip) {
+  const rows = db.prepare(
+    `SELECT t.id AS id, t.local_id AS local_id
+         FROM task_auto a
+         JOIN tasks t ON t.id = a.task_id
+         JOIN workstreams w ON w.id = t.workstream_id AND w.name = ?
+        WHERE t.status = 'CLOSED' AND t.substate = 'done' ORDER BY t.id`
+  ).all(workstream);
+  for (const r of rows) {
+    if (!autoPermitted(db, r.id)) continue;
+    const attempt = deliveredOf(db, r.id)?.receipt.attemptKey;
+    if (attempt === void 0) continue;
+    const callId = `refute:${workstream}:${r.local_id}:${attempt}`;
+    if (skip.has(callId)) continue;
+    const call = getDelegateCall(db, callId);
+    if (call === void 0) return { callId, task: r.local_id, attempt, workstream };
+    if (call.caller !== caller) continue;
+    if (["starting", "running", "recording"].includes(call.state)) {
+      return { callId, task: r.local_id, attempt, workstream, call };
+    }
+  }
+  return void 0;
+}
+function checkerOf(db, c) {
+  const taskId = taskIdFor(db, c.task, c.workstream);
+  const receipt = taskId === null ? void 0 : getReceipt(db, taskId, `manual:${c.task}`);
+  const agent = receipt === void 0 ? void 0 : savedIdentity(db, receipt).agent;
+  return receipt !== void 0 && agent !== void 0 ? { receipt, agent } : void 0;
+}
+function checkerRefs(db, workstream, caller) {
+  const refs = [];
+  for (const c of liveCalls(db, workstream, caller)) {
+    const held = checkerOf(db, c);
+    if (held === void 0) continue;
+    const { receipt, agent } = held;
+    refs.push({
+      kind: "agent",
+      workstream: agent.workstreamName,
+      id: agent.name,
+      afterRuns: receipt.runs ?? 0,
+      ...receipt.incarnation !== null ? { incarnation: receipt.incarnation } : {}
+    });
+  }
+  return refs;
+}
+function liveCalls(db, workstream, caller) {
+  return db.prepare(
+    "SELECT call_id FROM delegate_calls WHERE caller = ? AND call_id LIKE ? AND state IN ('running','recording')"
+  ).all(caller, `refute:${workstream}:%`).map((r) => getDelegateCall(db, r.call_id)).filter((c) => c !== void 0);
+}
+var stem = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 13).replace(/^-+|-+$/g, "");
+function checkerText(db, ws, task, attempt) {
+  const { briefN, reportN } = pinnedNotes(db, ws, task);
+  const part = (what, n) => n < 1 ? `${what}: (none)` : `${what} (note #${n}):
+${getTaskNote(db, task, ws, n).content.trimEnd()}`;
+  return [
+    `You are an independent checker of the work on task ${task} (workstream ${ws}), attempt ${attempt}. Read only: do not edit, commit, merge, close or accept anything.`,
+    part("Pinned brief", briefN),
+    part("The worker's report", reportN),
+    "Try to refute the claim that the work meets the brief: read the code and run the checks yourself. End your final message with a line starting `VERDICT:` and one of CONFIRMED, REFUTED, UNVERIFIED, then `EVIDENCE:` lines naming what you ran and saw."
+  ].join("\n\n");
+}
+var planCheck = (c) => ({
+  kind: "refute",
+  task: c.task,
+  key: c.callId,
+  state: c.call?.state ?? "new"
+});
+async function runCheck(db, c, deps) {
+  const base = { task: c.task, key: c.callId };
+  const taskId = taskIdFor(db, c.task, c.workstream);
+  const auto = taskId === null ? void 0 : getAutoConfig(db, taskId);
+  let call = c.call;
+  if (call === void 0) {
+    const cli = deps.cli ?? auto?.cli ?? "pi";
+    if (!speaksMuCtl(cli, resolveCliCommand(cli))) {
+      return {
+        kind: "skip",
+        ...base,
+        cli,
+        reason: `cli ${cli} cannot report an answer over ctl: pass --refute-cli pi`
+      };
+    }
+    try {
+      call = registerDelegateCall(db, {
+        callId: c.callId,
+        caller: deps.caller,
+        workstream: REFUTE_WORKSTREAM,
+        wave: `refute-${c.workstream}`,
+        record: { workstream: c.workstream, task: c.task },
+        state: "starting",
+        request: {
+          text: checkerText(db, c.workstream, c.task, c.attempt),
+          label: `refute-${c.task}`,
+          cli,
+          timeoutS: CHECK_TIMEOUT_S
+        }
+      }).call;
+    } catch (err) {
+      if (err instanceof DelegateCallConflictError) {
+        return { kind: "skip", ...base, reason: "another mu registered this check first" };
+      }
+      throw err;
+    }
+  }
+  if (call.state === "starting") return launch(db, call, base);
+  return readOne(db, call, base, deps);
+}
+async function launch(db, call, base) {
+  const cli = call.request.cli ?? "pi";
+  try {
+    const out = await spawnForTask(db, {
+      task: call.task,
+      text: call.request.text,
+      spawn: {
+        name: `delegate-refute-${stem(base.task)}`,
+        workstream: call.workstream,
+        cli,
+        nextFree: true
+      }
+    });
+    const agent = out.agent?.name ?? out.receipt.name;
+    if (out.state === "unknown") {
+      if (!out.replay)
+        return {
+          kind: "refute",
+          ...base,
+          agent,
+          cli,
+          state: "starting",
+          reason: out.reason ?? "delivery unknown"
+        };
+      return end(
+        db,
+        call,
+        base,
+        "error",
+        `delivery unknown after one probe (${out.reason ?? "no reply"}); pane ${agent} kept`
+      );
+    }
+    try {
+      markDelegate(db, call.callId, "running", { agent });
+    } catch (err) {
+      if (!(err instanceof DelegateStateError)) throw err;
+    }
+    return { kind: "refute", ...base, agent, cli, state: "running" };
+  } catch (err) {
+    if (err instanceof NoMultiplexerError) throw err;
+    if (err instanceof SpawnAttemptBusyError) {
+      return { kind: "skip", ...base, reason: "another mu is launching this checker" };
+    }
+    const reason = err instanceof Error ? err.message : String(err);
+    const done = end(db, call, base, "error", `the checker could not be started: ${reason}`);
+    return { ...done, kind: "failed", reason };
+  }
+}
+function end(db, call, base, outcome, text, agent) {
+  const r = finishDelegate(db, call.callId, {
+    outcome,
+    ...text !== void 0 ? { text } : {},
+    elapsedMs: Math.max(0, Date.now() - Date.parse(call.updatedAt)),
+    author: agent ?? call.agent ?? "next"
+  });
+  return {
+    kind: "refute",
+    ...base,
+    ...call.agent !== null ? { agent: call.agent } : {},
+    state: r.state,
+    ...r.verdict !== null ? { verdict: r.verdict } : {},
+    ...r.error !== void 0 ? { reason: r.error } : {}
+  };
+}
+async function readOne(db, call, base, deps) {
+  const held = checkerOf(db, call);
+  if (held === void 0) {
+    return end(db, call, base, "died", "the checker's agent is gone", call.agent ?? "next");
+  }
+  const { receipt, agent } = held;
+  const got = await deps.read(
+    db,
+    agent,
+    { afterRuns: receipt.runs ?? 0, inc: receipt.incarnation },
+    { ...deps.signal !== void 0 ? { signal: deps.signal } : {}, ms: READ_MS }
+  );
+  if (got.kind === "running") {
+    const late = Date.now() - Date.parse(call.updatedAt) > (call.request.timeoutS ?? CHECK_TIMEOUT_S) * 1e3;
+    if (!late) return { kind: "refute", ...base, agent: agent.name, state: "running" };
+    return end(db, call, base, "timeout", void 0, agent.name);
+  }
+  return end(
+    db,
+    call,
+    base,
+    got.kind === "died" ? "died" : got.outcome,
+    got.kind === "answer" ? got.text : void 0,
+    agent.name
+  );
+}
+
+// src/next.ts
+var NextArgError = class extends Error {
+  name = "NextArgError";
+};
+var DEFAULT_NEXT_CAP = 5;
+var MAX_NEXT_CAP = 100;
+function checkCap(cap) {
+  if (cap === void 0) return DEFAULT_NEXT_CAP;
+  if (!Number.isInteger(cap) || cap < 1 || cap > MAX_NEXT_CAP) {
+    throw new NextArgError(`--cap must be an integer from 1 to ${MAX_NEXT_CAP} (got ${cap})`);
+  }
+  return cap;
+}
+function checkWorkers(n) {
+  if (n === void 0) return void 0;
+  if (!Number.isInteger(n) || n < 1 || n > MAX_NEXT_CAP) {
+    throw new NextArgError(`--workers must be an integer from 1 to ${MAX_NEXT_CAP} (got ${n})`);
+  }
+  return n;
+}
+function checkTimeout(ms) {
+  if (ms === void 0) return WAIT_HEARTBEAT_CAP_MS;
+  if (!Number.isFinite(ms) || ms < 0) {
+    throw new NextArgError(`--timeout must be a number of seconds, 0 or more (got ${ms / 1e3})`);
+  }
+  return ms === 0 ? WAIT_HEARTBEAT_CAP_MS : Math.min(ms, WAIT_HEARTBEAT_CAP_MS);
+}
+function select(db, ws, done) {
+  const pending = pendingAttempts(db, ws).find((t) => !done.has(t));
+  if (pending !== void 0) return { task: pending, resume: true };
+  const ready = authorisedReady(db, ws).find((t) => !done.has(t.name));
+  return ready === void 0 ? void 0 : { task: ready.name, resume: false };
+}
+function needsPane(db, ws, c) {
+  if (!c.resume) return true;
+  const id = taskIdFor(db, c.task, ws);
+  const receipt = id === null ? void 0 : readAttempt(db, id).receipt;
+  return receipt?.state === "reserved";
+}
+function counts(m) {
+  if (m.kind === "skip" || m.kind === "abandoned" || m.kind === "attention") return false;
+  if (m.kind === "needs_human") return m.checked !== void 0;
+  return true;
+}
+var HoldHumanStop = class extends Error {
+};
+var DEAD_OR_ERRORED = (r) => {
+  const e = r.event;
+  if (e.kind === "dead") return true;
+  if (e.kind !== "settled" || e.ref === null) return false;
+  const snap = r.refs.find(
+    (s) => s.ref.kind === e.ref?.kind && s.ref.workstream === e.ref.workstream && s.ref.id === e.ref.id
+  );
+  return snap?.lastError !== void 0 && snap.close?.applied !== true;
+};
+var refText = (r) => r.kind === "delegate" ? `delegate:${r.id}` : `${r.kind}:${r.workstream}/${r.id}`;
+async function executeNext(db, opts) {
+  const cap = checkCap(opts.cap);
+  const timeoutMs = checkTimeout(opts.timeoutMs);
+  const workers = checkWorkers(opts.workers);
+  const refute = opts.refute === true;
+  if (refute && opts.caller === "") {
+    throw new NextArgError(
+      "--refute needs a caller identity (a managed agent, or PI_SESSION_ID): a checker belongs to the caller that launched it"
+    );
+  }
+  const ws = opts.workstream;
+  const out = { workstream: ws, dry: opts.dry === true, cap, used: 0, moves: [] };
+  const done = /* @__PURE__ */ new Set();
+  const ingest = opts.ingest ?? (() => ambientIngest(db, { quiet: true }));
+  const humanStop = () => {
+    const needs = openHumanNeeds(db, opts.caller);
+    if (needs.length === 0) return false;
+    out.stopped = "human";
+    out.human_needed = needs;
+    return true;
+  };
+  const ctx = { db, ws, caller: opts.caller, humanStop, workers };
+  const observe = opts.observe ?? observeWorkers(db);
+  const deadline = Date.now() + timeoutMs;
+  const aborted = () => {
+    if (opts.signal?.aborted !== true) return false;
+    out.stopped = "interrupted";
+    return true;
+  };
+  const told = /* @__PURE__ */ new Set();
+  const tell = (task, reason, agent) => {
+    if (told.has(`${task}|${reason}`)) return;
+    told.add(`${task}|${reason}`);
+    out.moves.push({ kind: "attention", task, ...agent !== void 0 ? { agent } : {}, reason });
+  };
+  const attend = () => {
+    for (const a of exhaustedAfterDeath(db, ws)) tell(a.task, a.reason);
+  };
+  const pass = async () => {
+    let actions;
+    for (; ; ) {
+      if (aborted()) return;
+      if (out.used >= cap) {
+        if (out.stopped === void 0 && (select(db, ws, done) !== void 0 || (actions?.length ?? 0) > 0 || refute && nextCheck(db, ws, opts.caller, done) !== void 0)) {
+          out.stopped = "cap";
+        }
+        return;
+      }
+      if (!out.dry) await ingest();
+      if (aborted()) return;
+      if (humanStop()) return;
+      if (actions === void 0) {
+        const found = out.dry ? [] : await scanRecovery(
+          db,
+          ws,
+          observe,
+          opts.signal !== void 0 ? { signal: opts.signal } : {}
+        );
+        if (aborted()) return;
+        if (out.dry) out.inFlight = inFlightWorkers(db, ws).map((w) => w.task);
+        actions = [];
+        for (const a of found) {
+          if (a.kind === "attention") tell(a.task, a.reason, a.agent);
+          else actions.push(a);
+        }
+      }
+      const act = actions.shift();
+      if (act !== void 0 && !out.dry) {
+        const move2 = await recover(ctx, act, observe, opts.signal);
+        if (act.kind === "retry") done.add(act.task);
+        out.moves.push(move2);
+        if (counts(move2)) out.used++;
+        if (move2.kind === "failed") {
+          out.stopped = "failed";
+          return;
+        }
+        continue;
+      }
+      const next = select(db, ws, done);
+      if (next === void 0) {
+        const check = refute ? nextCheck(db, ws, opts.caller, done) : void 0;
+        if (check !== void 0) {
+          done.add(check.callId);
+          const move2 = out.dry ? planCheck(check) : await runCheck(db, check, {
+            caller: opts.caller,
+            read: opts.readChecker ?? readChecker,
+            ...opts.refuteCli !== void 0 ? { cli: opts.refuteCli } : {},
+            ...opts.signal !== void 0 ? { signal: opts.signal } : {}
+          });
+          out.moves.push(move2);
+          if (counts(move2)) out.used++;
+          if (move2.kind === "failed" && !out.dry) {
+            out.stopped = "failed";
+            return;
+          }
+          continue;
+        }
+        attend();
+        return;
+      }
+      if (workers !== void 0 && needsPane(db, ws, next) && liveWorkers(db, ws) >= workers) {
+        tell(
+          next.task,
+          `worker ceiling ${workers} reached (${liveWorkers(db, ws)} working): no new pane until one finishes`
+        );
+        out.stopped = "workers";
+        return;
+      }
+      done.add(next.task);
+      const move = out.dry ? planMove(db, ws, next.task, next.resume) : next.resume ? await resume(ctx, next.task) : await allocate(ctx, next.task);
+      out.moves.push(move);
+      if (counts(move)) out.used++;
+      if (move.kind === "failed" && !out.dry) {
+        out.stopped = "failed";
+        return;
+      }
+    }
+  };
+  for (let waits = 0; ; ) {
+    const before = out.used;
+    await pass();
+    const atCeiling = out.stopped === "workers";
+    if (opts.hold !== true || out.dry || out.stopped !== void 0 && !atCeiling) return out;
+    if (waits > 0 && out.used === before) return out;
+    const inFlight = inFlightWorkers(db, ws);
+    const checkers = refute ? checkerRefs(db, ws, opts.caller) : [];
+    if (inFlight.length === 0 && checkers.length === 0) {
+      out.held = { waits, event: "none", ref: null, exit: 0, timedOut: false, open: [] };
+      return out;
+    }
+    const left = deadline - Date.now();
+    if (left <= 0) {
+      out.held = { waits, event: "heartbeat", ref: null, exit: 0, timedOut: true, open: [] };
+      return out;
+    }
+    const refs = checkers.concat(
+      inFlight.flatMap((w) => [
+        { kind: "task", workstream: ws, id: w.task },
+        {
+          kind: "agent",
+          workstream: w.agent.workstreamName,
+          id: w.agent.name,
+          ...w.runs !== null ? { afterRuns: w.runs } : {},
+          ...w.incarnation !== null ? { incarnation: w.incarnation } : {}
+        }
+      ])
+    );
+    waits++;
+    let res;
+    try {
+      res = await (opts.wait ?? waitWithActions)(db, refs, {
+        callers: opts.caller === "" ? [] : [opts.caller],
+        mode: "first",
+        eventScope: "refs",
+        timeoutMs: left,
+        ...opts.signal !== void 0 ? { signal: opts.signal } : {},
+        onStall: opts.onStall ?? "exit",
+        ...ctlAgentHooks(db),
+        beforePoll: async () => {
+          if (humanStop()) throw new HoldHumanStop();
+        }
+      });
+    } catch (err) {
+      if (err instanceof HoldHumanStop) return out;
+      if (err instanceof AgentRestartedError) {
+        out.moves.push({ kind: "attention", task: "", reason: err.message });
+        out.held = { waits, event: "restarted", ref: null, exit: 7, timedOut: false, open: [] };
+        return out;
+      }
+      throw err;
+    }
+    out.held = {
+      waits,
+      event: res.event.kind,
+      ref: res.event.ref === null ? null : refText(res.event.ref),
+      exit: res.exit,
+      timedOut: res.timedOut,
+      open: res.refs.filter((x) => !x.fired && !x.dead).slice(0, 8).map((x) => ({
+        ref: refText(x.ref),
+        status: x.status,
+        ...x.lastError !== void 0 ? { lastError: x.lastError.slice(0, 200) } : {}
+      }))
+    };
+    if (res.interrupted) {
+      out.stopped = "interrupted";
+      return out;
+    }
+    const freed = atCeiling && res.event.kind === "closed";
+    const checkerEvent = checkers.some(
+      (c) => res.event.ref?.kind === "agent" && res.event.ref.id === c.id
+    );
+    if (res.event.kind === "heartbeat" || !DEAD_OR_ERRORED(res) && !freed && !checkerEvent) {
+      return out;
+    }
+    if (atCeiling) out.stopped = void 0;
+    done.clear();
+  }
+}
+function planMove(db, ws, task, resume2) {
+  const taskId = taskIdFor(db, task, ws);
+  if (resume2 && taskId !== null) {
+    const { record, receipt } = readAttempt(db, taskId);
+    if (record !== void 0 && receipt !== void 0) {
+      const base = { task, attempt: record.attempt, key: record.key, cli: record.cli };
+      const end2 = unreconcilable(db, ws, task, receipt);
+      if (end2 !== void 0) return { kind: end2.state, ...base, reason: end2.reason };
+      return {
+        kind: "replay",
+        ...base,
+        agent: receipt.name,
+        state: receipt.state
+      };
+    }
+  }
+  const planned = planAttempt(db, ws, task);
+  if (!planned.ok) return { kind: "skip", task, reason: planned.reason };
+  const p = planned.plan;
+  return { kind: "spawn", task, attempt: p.attempt, key: p.key, agent: p.name, cli: p.cli };
+}
+function unreconcilable(db, ws, task, receipt) {
+  const t = getTask(db, task, ws);
+  if (t === void 0) return { state: "abandoned", reason: "the task is gone" };
+  if (t.status === "CLOSED") return { state: "abandoned", reason: "the task is closed" };
+  const sent = receipt.state === "sending" || receipt.state === "unknown";
+  const lost = (reason) => ({
+    state: sent ? "needs_human" : "abandoned",
+    reason
+  });
+  if (receipt.state === "reserved") {
+    return t.ownerId === null ? void 0 : lost("the task is owned by another agent");
+  }
+  const id = savedIdentity(db, receipt);
+  if (id.stale !== void 0) {
+    return lost(`the agent of this attempt is ${id.stale}`);
+  }
+  if (sent && receipt.transport !== "ctl") {
+    return lost("the send went through the pane: there is no receipt to ask");
+  }
+  return void 0;
+}
+function park(ctx, task, record, end2) {
+  if (end2.state === "needs_human" && ctx.caller !== "") {
+    recordHumanNeeded(ctx.db, {
+      workstream: ctx.ws,
+      caller: ctx.caller,
+      reason: `attempt ${record.key} of task ${task} may have been delivered and cannot be confirmed (${end2.reason}); never resent`
+    });
+  }
+  const taskId = taskIdFor(ctx.db, task, ctx.ws);
+  if (taskId !== null) endAttempt(ctx.db, taskId, record.key, end2);
+  return {
+    kind: end2.state,
+    task,
+    attempt: record.attempt,
+    key: record.key,
+    cli: record.cli,
+    reason: end2.reason
+  };
+}
+function guardOf(ctx, task, key) {
+  let refusedAt;
+  const guard = (phase) => {
+    const stop = (why) => {
+      refusedAt = phase;
+      throw new SpawnAttemptGuardError(task, key, why);
+    };
+    if (ctx.humanStop()) stop("this caller has an open human need");
+    const taskId = taskIdFor(ctx.db, task, ctx.ws);
+    if (taskId === null || !autoPermitted(ctx.db, taskId)) {
+      stop("it is no longer authorised for this machine");
+    }
+    if (phase === "spawn" && !listReady(ctx.db, ctx.ws).some((t) => t.name === task)) {
+      stop("it is no longer ready");
+    }
+    if (phase === "spawn" && ctx.workers !== void 0 && liveWorkers(ctx.db, ctx.ws) >= ctx.workers) {
+      stop(`the worker ceiling ${ctx.workers} is reached`);
+    }
+  };
+  return { guard, refusedAt: () => refusedAt };
+}
+function outcomeMove(kind, task, rec, out) {
+  const reason = out.reason;
+  return {
+    kind,
+    task,
+    attempt: rec.attempt,
+    key: rec.key,
+    agent: out.agent?.name ?? out.receipt.name,
+    cli: rec.cli,
+    state: out.state,
+    ...out.stale !== void 0 ? { stale: out.stale } : {},
+    ...reason !== void 0 ? { reason } : {},
+    ...out.checked !== void 0 ? { checked: out.checked } : {}
+  };
+}
+async function drive(ctx, task, kind, rec) {
+  const { db, ws } = ctx;
+  const g = guardOf(ctx, task, rec.key);
+  try {
+    const out = await spawnAutoAttempt(db, {
+      task,
+      text: rec.text,
+      key: rec.key,
+      guard: g.guard,
+      ...rec.inPlace === true ? { keepAgent: true } : {},
+      spawn: {
+        name: rec.name,
+        workstream: ws,
+        cli: rec.cli,
+        ...rec.worktree ? { worktree: true } : {},
+        nextFree: true
+      }
+    });
+    const move = outcomeMove(kind, task, rec, out);
+    if (kind === "replay" && out.state === "unknown") {
+      return {
+        ...park(ctx, task, rec, {
+          state: "needs_human",
+          reason: out.reason ?? "the send could not be confirmed"
+        }),
+        ...out.checked !== void 0 ? { checked: out.checked } : {}
+      };
+    }
+    return move;
+  } catch (err) {
+    if (err instanceof NoMultiplexerError) throw err;
+    const base = { task, attempt: rec.attempt, key: rec.key, cli: rec.cli };
+    if (err instanceof SpawnAttemptBusyError) {
+      return { kind: "skip", ...base, reason: `attempt in flight: ${err.message}` };
+    }
+    if (err instanceof SpawnAttemptGuardError) {
+      const kind2 = g.refusedAt() === "send" ? "rolled_back" : "skip";
+      return { kind: kind2, ...base, reason: err.message };
+    }
+    const reason = err instanceof Error ? err.message : String(err);
+    const taskId = taskIdFor(db, task, ws);
+    const left = taskId === null ? void 0 : getReceipt(db, taskId, rec.key);
+    if (left !== void 0 && IN_FLIGHT_STATES.has(left.state)) {
+      const sent = left.state === "sending" || left.state === "unknown";
+      park(ctx, task, rec, { state: sent ? "needs_human" : "abandoned", reason });
+    }
+    return { kind: "failed", ...base, reason };
+  }
+}
+async function resume(ctx, task) {
+  const { db, ws } = ctx;
+  const taskId = taskIdFor(db, task, ws);
+  const { record, receipt } = taskId === null ? {} : readAttempt(db, taskId);
+  if (record === void 0 || receipt === void 0) {
+    return { kind: "skip", task, reason: "no stored attempt" };
+  }
+  const end2 = unreconcilable(db, ws, task, receipt);
+  if (end2 !== void 0) return park(ctx, task, record, end2);
+  return drive(ctx, task, "replay", record);
+}
+async function allocate(ctx, task) {
+  const reserved = reserveAttempt(ctx.db, ctx.ws, task);
+  if (!reserved.ok) {
+    return {
+      kind: "skip",
+      task,
+      reason: `attempt ${reserved.code === "in-flight" ? "in flight" : reserved.code}: ${reserved.reason}`
+    };
+  }
+  return drive(ctx, task, "spawn", reserved.plan);
+}
+async function recover(ctx, act, observe, signal) {
+  const { db, ws } = ctx;
+  const skip = (reason) => ({ kind: "skip", task: act.task, reason });
+  if (ctx.humanStop()) return skip("this caller has an open human need");
+  const taskId = taskIdFor(db, act.task, ws);
+  if (taskId === null || !autoPermitted(db, taskId)) {
+    return skip("it is no longer authorised for this machine");
+  }
+  if (act.kind === "reap") {
+    const a = act.agent;
+    const now2 = getAgent(db, a.name, a.workstreamName);
+    if (now2?.host != null) return skip("a remote worker is never reaped from here");
+    const deleted = deleteAgent(db, a.name, a.workstreamName, {
+      paneId: a.paneId,
+      incarnation: a.incarnation
+    });
+    return deleted ? { kind: "reap", task: act.task, agent: a.name, reason: act.why } : skip("the worker was replaced before it could be reaped");
+  }
+  const { agent } = act.target;
+  const row = getAgent(db, agent.name, ws);
+  if (row === void 0) return skip("the worker is gone");
+  const now = (await observe([row], { ms: OBSERVE_MS, ...signal !== void 0 ? { signal } : {} })).get(workerKey(row));
+  if (now === void 0 || !idleOnCtl(now) || now.incarnation !== act.target.pi || now.runs !== act.target.errorRuns || now.lastError === void 0) {
+    return skip("the worker is no longer idle at the errored run: left to the wait");
+  }
+  const reserved = reserveRetry(db, ws, act.task, act.target);
+  if (!reserved.ok) {
+    return skip(
+      `retry ${reserved.code === "ceiling" ? "ceiling" : reserved.code}: ${reserved.reason}`
+    );
+  }
+  const { task: _t, taskId: _i, workstream: _w, revision: _r, ...rec } = reserved.plan;
+  const move = await drive(ctx, act.task, "retry", rec);
+  return { ...move, reason: move.reason ?? `API error: ${act.error.slice(0, 200)}` };
+}
+
+// src/pi-migrate.ts
+import { createHash } from "crypto";
+import { lstatSync as lstatSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync, realpathSync as realpathSync2, renameSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, isAbsolute, join as join3, relative, resolve as resolve2, sep as sep2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/pi-known-skills.ts
+var KNOWN_SKILL_DIGESTS = [
+  "bab34e7d50b31dd9960f64a8192f78f023ce3e9a5dd6a080bda3c7d3aaf68ba8",
+  // v0.2.0
+  "a76d272878cb90afc4f5a64ef903a0e80dd3eb7fd92dda23bcbba03854786051",
+  // v0.3.0
+  "cb4116919f86bff5c61268cce5059c0965b6c5673d92fb1466ebe654c560425d",
+  // v0.3.1
+  "1fc6a019ee71c06d311070058ba76572f6b778e160a5ebd93faeef32002a67dd",
+  // v0.3.2
+  "4029bcea85a7470798261041c3626b7fea16f9c84d195a3c4266221e7af4fafb",
+  // v0.4.0
+  "272984f7db1812241f8659a71deeac1e7d81367ecf843d6436385d6cec410000",
+  // v0.4.1
+  "7d58aebec9bbb40cad90b6da9e9a369cee0aebed03d194ea153c8e4229fbfe16",
+  // v0.4.5
+  "e4645a869fbd5153a7390d1cbfe2f3842038f895b4f754a4c44e23512270b5c7",
+  // v1.0.0
+  "41479003fe7f7a7d757413dcf31eb46330b9689c70aa0200347aaf6bafd972f1",
+  // v1.0.1
+  "1ba368054d76b931639e3dfe02bd53ed8277e47ab28d989ce3bfb7df7497dc7e",
+  // v1.1.0
+  "e10e2cf93a31a6b24ce1f19951e1a278299b0c33f8020bd293eff807b24fb20f",
+  // v1.1.1
+  "b38c8da4c685b9478aebb13905607bf295af9d9880c7da2aa1e750f24d508e28",
+  // v1.2.0
+  "82c14d2c9cbe7bf81f89e4031aeccee8284ffd4ddddea298547b31e1f78bef39",
+  // v1.3.0
+  "f787792a820b08aaa7cc338931bf239b5b54e3b536d06127aa8da2d9c938ef5a",
+  // v1.3.2
+  "9c5ac614ff9bf3db7d8c5aca3d2d422f8c175efa35533d0c2e174bd74682e073",
+  // v1.4.0
+  "6aa1d11a96d9ccd7587e979b8ef2d48d55d9b486f2ccfd160e228c57671cf340",
+  // v1.6.0
+  "c33778ae1c9efbb3306395e970c2e9d4a859e19aea11d6ba0429c38ea7f9d05a",
+  // v2.0.0
+  "8aabe979d125399274e6ed42c40353f775be61730e4c07c882d16f68d6fd3da8",
+  // v3.0.0
+  "bce15b51a9d8b1d0d277e7e3a79ff902d7ab306085c51eb5cb7e8e126b92564c",
+  // v3.1.0
+  "7dba4e5b3058e14c4314f886a26a5b5f50b99a3180d5fbe81b4751ac4e187f49",
+  // v3.10.0
+  "177fdc1ab4c273eef1ad004732c35fc4820a72b57991e4754d5f53063d782e49",
+  // v3.10.1
+  "a648aed46f7e1120ef8fbf021748a40c5434621e036fc443a817899a87dbb028",
+  // v3.11.0
+  "ace13205c56b40bb8de0265e4f524eec18a0583b508d7951eb6185c102e4470a",
+  // v3.13.0
+  "ff47c6b99435f0b30ef9fea3f6d8384c5718d7c952bbe3cada79b82ea70680fc",
+  // v3.13.2
+  "76e5b12be5e78f4b53981718938c33377f896be41b70be88c6feedc0e101af2b",
+  // v3.13.3
+  "3bd49e0b22440bd670e915683409e8929579128a9ea3f50d6c7ea3eb6ea124cc",
+  // v3.2.0
+  "13428e619c423d8e3dc39772343ac6be12b08b0e648113d791364c447d4f6dee",
+  // v3.2.1
+  "258fc3f9212387669f4b8a9442cdebfd04736378fedc4055acf2096b7759e962",
+  // v3.3.0
+  "f1a31d16d644bc484b3755ad9019e760098e8f089359cbd12dad3e4570ef14c0",
+  // v3.4.0
+  "75cb30f7291b5613df1ffa11d497ff91972c576c625141c6cb7a5ac34f206d6b",
+  // v3.5.0
+  "4123cd6e5a19b27bae298a1b56896e06237e8187ace51ccd8aef99c6486a6800",
+  // v3.7.0
+  "848eb0fe7fff3108162027f65fe1482675e5ecf074312e9799e6056c6212800f",
+  // v3.8.0
+  "7d9784b1c881f545e376a5ddb37da66b589e12b4dadbb204db69767835887546"
+  // v3.8.1
+];
+
+// src/pi-migrate.ts
+var MU_SHIM_MARKER = "// mu:shim";
+function lstatOrUndefined(path) {
+  try {
+    return lstatSync2(path);
+  } catch {
+    return void 0;
+  }
+}
+function freeName(dest) {
+  if (!lstatOrUndefined(dest)) return dest;
+  for (let i = 1; ; i++) {
+    const candidate = `${dest}.${i}`;
+    if (!lstatOrUndefined(candidate)) return candidate;
+  }
+}
+function park2(from, dest) {
+  const to = freeName(dest);
+  mkdirSync2(join3(to, ".."), { recursive: true });
+  renameSync(from, to);
+  return to;
+}
+var SHIM_HEAD = `${MU_SHIM_MARKER}
+// Generated by \`mu link pi\`. Do not edit.
+//
+// A re-export, not a copy: the extension code lives in the mu install, so
+// upgrading mu upgrades the extension. Re-run \`mu link pi\` only if the
+// install path itself moves.
+const { default: extension } = await import(`;
+var SHIM_TAIL = `);
+export default extension;
+`;
+function isGeneratedImport(arg) {
+  try {
+    const url = JSON.parse(arg);
+    return typeof url === "string" && JSON.stringify(url) === arg && new URL(url).href === url && url.startsWith("file:///") && url.endsWith("/dist/extension/mu-pi.js");
+  } catch {
+    return false;
+  }
+}
+function isMuShimText(text) {
+  return text.startsWith(SHIM_HEAD) && text.endsWith(SHIM_TAIL) && isGeneratedImport(text.slice(SHIM_HEAD.length, text.length - SHIM_TAIL.length));
+}
+function isMuShim(path) {
+  try {
+    return isMuShimText(readFileSync(path, "utf8"));
+  } catch {
+    return false;
+  }
+}
+function defaultPackageRoot() {
+  return resolve2(dirname3(fileURLToPath(import.meta.url)), "..");
+}
+function skillDirDigest(dir) {
+  const lines = [];
+  const walk = (d) => {
+    for (const ent of readdirSync(d, { withFileTypes: true })) {
+      const p = join3(d, ent.name);
+      if (ent.isDirectory()) {
+        if (!walk(p)) return false;
+      } else if (ent.isFile()) {
+        const sum = createHash("sha256").update(readFileSync(p)).digest("hex");
+        lines.push(`${relative(dir, p).split(sep2).join("/")}\0${sum}
+`);
+      } else return false;
+    }
+    return true;
+  };
+  try {
+    if (!walk(dir)) return void 0;
+  } catch {
+    return void 0;
+  }
+  return createHash("sha256").update(lines.sort().join("")).digest("hex");
+}
+function isMuSkill(path, st, root, known) {
+  try {
+    if (st.isSymbolicLink()) {
+      const own = realpathSync2(join3(root, "skills", "mu"));
+      const rel = relative(own, realpathSync2(path));
+      return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+    }
+    if (!st.isDirectory()) return false;
+    const digest = skillDirDigest(path);
+    return digest !== void 0 && known.includes(digest);
+  } catch {
+    return false;
+  }
+}
+function migratePi(opts = {}) {
+  const home = opts.home ?? process.env.MU_PI_HOME ?? homedir();
+  const extPath = join3(home, ".pi", "agent", "extensions", "mu.ts");
+  const skillPath = join3(home, ".agents", "skills", "mu");
+  const extSt = lstatOrUndefined(extPath);
+  const extension = {
+    path: extPath,
+    state: !extSt ? "absent" : extSt.isFile() && isMuShim(extPath) ? "shim" : "foreign",
+    moved: false
+  };
+  const skSt = lstatOrUndefined(skillPath);
+  const skill = {
+    path: skillPath,
+    state: !skSt ? "absent" : isMuSkill(
+      skillPath,
+      skSt,
+      opts.packageRoot ?? defaultPackageRoot(),
+      opts.knownSkillDigests ?? KNOWN_SKILL_DIGESTS
+    ) ? "shim" : "foreign",
+    moved: false
+  };
+  if (opts.apply === true) {
+    if (extension.state === "shim") {
+      extension.to = park2(extPath, join3(home, ".pi", "agent", "disabled", "mu.ts.shim"));
+      extension.moved = true;
+    }
+    if (skill.state === "shim") {
+      skill.to = park2(skillPath, join3(home, ".agents", "disabled", "skills", "mu"));
+      skill.moved = true;
+    }
+  }
+  const guidance = [];
+  if (opts.apply !== true && (extension.state === "shim" || skill.state === "shim")) {
+    guidance.push("Nothing moved. Re-run with --apply to move the mu-owned files aside.");
+  }
+  for (const e of [extension, skill]) {
+    if (e.state === "foreign") {
+      guidance.push(
+        `Left ${e.path} in place: not proven mu's. If it duplicates the package, move it aside yourself.`
+      );
+    }
+  }
+  if (extension.moved || skill.moved) {
+    guidance.push(
+      "Running pi agents keep the old extension until they restart: restart pi or run /reload."
+    );
+  }
+  guidance.push("Install the package once: pi install npm:@mu-crew/mu");
+  return { extension, skill, guidance };
+}
+
+// src/remote-collect.ts
+import { createHash as createHash2 } from "crypto";
+import { rm } from "fs/promises";
+import { dirname as dirname4, join as join4, resolve as resolve3 } from "path";
+var REMOTE_COLLECT_TIMEOUT_MS = 3e5;
+var RemoteCollectUnsupportedError = class extends Error {
+  name = "RemoteCollectUnsupportedError";
+  constructor(agent, why) {
+    super(say("remote.collect_unsupported", agent, why));
+  }
+};
+var RemoteCollectError = class extends Error {
+  constructor(host, detail) {
+    super(say("remote.collect_failed", host, detail));
+    this.host = host;
+  }
+  host;
+  name = "RemoteCollectError";
+};
+function recoveryTarget(db, rec) {
+  return {
+    host: rec.host,
+    cwd: rec.cwd,
+    base: rec.base,
+    collectedHead: rec.collectedHead,
+    ownerId: rec.agentId,
+    record: (head) => head === rec.collectedHead ? recoveryHolds(db, rec) : setRecoveryCollectedHead(db, rec, head),
+    recheck: () => {
+      assertRecoveryUnchanged(db, rec);
+      assertRecoveryUsable(db, rec);
+    },
+    lost: () => new RemoteRecoveryRefusedError(
+      rec.workstream,
+      rec.name,
+      "changed",
+      `recovery ${rec.agentId} changed while its commits were being collected; the pin was restored`,
+      [rec.agentId]
+    )
+  };
+}
+function collectRef(workstream, name) {
+  return `refs/mu/collect/${workstream}/${name}`;
+}
+var firstLine = (s) => s.split("\n").find((l) => l.trim() !== "")?.trim() ?? "";
+function repoLockPath(db, repo) {
+  const base = db.memory || db.name === "" ? locksDir() : join4(dirname4(db.name), "locks");
+  return join4(base, `collect-${createHash2("sha256").update(repo).digest("hex").slice(0, 16)}.lock`);
+}
+async function collectRemoteAgent(db, opts) {
+  const { workstream, name, repo } = opts;
+  return withAgentLock(
+    db,
+    workstream,
+    name,
+    () => withFileLock(
+      repoLockPath(db, repo),
+      `collect ${repo}`,
+      async () => {
+        const agent = getAgent(db, name, workstream);
+        const rec = opts.recoveryId !== void 0 || agent === void 0 ? selectRemoteRecovery(db, workstream, name, opts.recoveryId) : void 0;
+        if (rec === void 0 && opts.recoveryId !== void 0) {
+          throw recoveryGone(workstream, name, opts.recoveryId);
+        }
+        let target;
+        if (rec !== void 0) {
+          assertRecoveryUsable(db, rec);
+          target = recoveryTarget(db, rec);
+        } else if (agent !== void 0) {
+          target = agentTarget(db, agent);
+        } else {
+          throw new AgentNotFoundError(name, workstream);
+        }
+        const { host, cwd, base } = target;
+        const r = await withHostChannel(
+          db,
+          host,
+          `collect:${workstream}/${name}`,
+          async (profile, lease) => {
+            if (rec !== void 0) assertRecoveryProfile(rec, profile);
+            const fetchHead = await git(["rev-parse", "--git-path", "FETCH_HEAD"], repo);
+            await rm(resolve3(repo, fetchHead), { force: true });
+            return runLeasedTemplate(
+              db,
+              lease,
+              profile,
+              "fetch",
+              { cwd },
+              REMOTE_COLLECT_TIMEOUT_MS,
+              repo
+            );
+          },
+          { paneAlive: localPaneAlive }
+        );
+        if (r.exitCode === null) {
+          throw new RemoteCollectError(
+            host,
+            `timed out after ${REMOTE_COLLECT_TIMEOUT_MS}ms; nothing recorded`
+          );
+        }
+        if (r.exitCode !== 0) {
+          const why = firstLine(r.stderr) || firstLine(r.stdout);
+          throw new RemoteCollectError(
+            host,
+            `fetch exited ${r.exitCode}${why === "" ? "" : `: ${why}`}; nothing recorded`
+          );
+        }
+        let head;
+        try {
+          head = await git(["rev-parse", "--verify", "FETCH_HEAD^{commit}"], repo);
+        } catch {
+          throw new RemoteCollectError(
+            host,
+            "the fetch template succeeded but left no commit in FETCH_HEAD (does it `git fetch`?); nothing recorded"
+          );
+        }
+        target.recheck();
+        const ref = collectRef(workstream, name);
+        const prior = await git(["rev-parse", "--verify", "-q", ref], repo).catch(() => void 0);
+        if (prior !== void 0 && prior !== head) {
+          const holders = pinnedByOthers(db, { workstream, name, agentId: target.ownerId }, prior);
+          if (holders.length > 0) {
+            throw new RemoteRecoveryRefusedError(
+              workstream,
+              name,
+              "pin",
+              `${ref} pins ${prior.slice(0, 12)}, the collected HEAD of recovery ${holders.join(", ")}; close that recovery first, then collect`,
+              holders
+            );
+          }
+        }
+        await git(["update-ref", ref, head], repo);
+        if (await git(["rev-parse", "--verify", ref], repo) !== head) {
+          throw new RemoteCollectError(host, `could not pin ${ref}; nothing recorded`);
+        }
+        const changed = head !== (target.collectedHead ?? base);
+        await recordCollected(target, head, ref, repo, prior);
+        return {
+          head,
+          ref,
+          merge: `git merge ${head}`,
+          changed,
+          ...rec === void 0 ? {} : { recoveryId: rec.agentId }
+        };
+      },
+      {
+        strict: true,
+        onUnavailable: () => {
+          throw new AgentLockBusyError(name, workstream);
+        }
+      }
+    )
+  );
+}
+function agentTarget(db, agent) {
+  const { host, cwd, base } = agent;
+  if (host === null || cwd === null) {
+    throw new RemoteCollectUnsupportedError(agent.name, "it is a local agent");
+  }
+  if (base === null) {
+    throw new RemoteCollectUnsupportedError(
+      agent.name,
+      "it was spawned with --cwd, not --worktree: there is no remote worktree of its own"
+    );
+  }
+  const fence = "id = ? AND pane_id = ? AND host IS ? AND cwd IS ? AND base IS ?";
+  const who = [agent.incarnation, agent.paneId, agent.host, agent.cwd, agent.base];
+  return {
+    host,
+    cwd,
+    base,
+    collectedHead: agent.collectedHead,
+    ownerId: agent.incarnation,
+    // An unchanged head writes nothing, but is still fenced: success names this incarnation.
+    record: (head) => head === agent.collectedHead ? db.prepare(`SELECT 1 FROM agents WHERE ${fence}`).all(...who).length === 1 : db.prepare(`UPDATE agents SET collected_head = ?, updated_at = ? WHERE ${fence}`).run(head, (/* @__PURE__ */ new Date()).toISOString(), ...who).changes === 1,
+    recheck: () => {
+      const now = getAgent(db, agent.name, agent.workstreamName);
+      if (now?.incarnation !== agent.incarnation || now.paneId !== agent.paneId) {
+        throw new AgentReplacedError(agent.name, agent.workstreamName, "collected");
+      }
+    },
+    lost: () => new AgentReplacedError(agent.name, agent.workstreamName, "collected")
+  };
+}
+async function recordCollected(target, head, ref, repo, prior) {
+  if (target.record(head)) return;
+  await (prior === void 0 ? git(["update-ref", "-d", ref, head], repo) : git(["update-ref", ref, prior, head], repo)).catch(() => {
+  });
+  throw target.lost();
+}
+
+// src/tasks/sort.ts
+var TASK_SORT_KEYS = ["roi", "recency", "age", "id"];
+function isTaskSortKey(s) {
+  return TASK_SORT_KEYS.includes(s);
+}
+function roiOf(t) {
+  return t.effortDays > 0 ? t.impact / t.effortDays : Number.POSITIVE_INFINITY;
+}
+function byRoiDesc(a, b) {
+  if (a.scored !== b.scored) return a.scored ? -1 : 1;
+  if (!a.scored) {
+    const byCreated = compareStrings(a.createdAt, b.createdAt);
+    return byCreated !== 0 ? byCreated : compareStrings(a.name, b.name);
+  }
+  const ra = roiOf(a);
+  const rb = roiOf(b);
+  if (rb !== ra) return rb - ra;
+  if (a.effortDays !== b.effortDays) return a.effortDays - b.effortDays;
+  return compareStrings(a.name, b.name);
+}
+function sortTasks(tasks, key) {
+  const out = tasks.slice();
+  switch (key) {
+    case "roi":
+      return out.sort(byRoiDesc);
+    case "recency":
+      return out.sort((a, b) => {
+        const byUpdated = compareStrings(b.updatedAt, a.updatedAt);
+        return byUpdated !== 0 ? byUpdated : compareStrings(a.name, b.name);
+      });
+    case "age":
+      return out.sort((a, b) => {
+        const byCreated = compareStrings(a.createdAt, b.createdAt);
+        return byCreated !== 0 ? byCreated : compareStrings(a.name, b.name);
+      });
+    case "id":
+      return out.sort((a, b) => compareStrings(a.name, b.name));
+  }
+}
+function relTimeBasisForSort(key) {
+  if (key === "recency") return "updatedAt";
+  if (key === "age") return "createdAt";
+  return null;
+}
+
+// src/state.ts
+var RECENT_CLOSED = 5;
+var BIG_WORKSTREAM_TASKS = 300;
+function taskActivity(db, workstream) {
+  const prefix = `${workstream}/`;
+  const rows = db.prepare(
+    `SELECT entity, key, MAX(seq) AS seq FROM ops
+        WHERE entity IN ('task', 'note', 'edge') AND key >= ? AND key < ?
+        GROUP BY entity, key`
+  ).all(prefix, `${workstream}0`);
+  const out = /* @__PURE__ */ new Map();
+  const bump = (id, seq) => {
+    if (seq > (out.get(id) ?? 0)) out.set(id, seq);
+  };
+  for (const r of rows) {
+    if (r.entity === "task") bump(r.key.slice(prefix.length), r.seq);
+    else if (r.entity === "note") bump(r.key.slice(prefix.length).split("#")[0] ?? "", r.seq);
+    else {
+      const [from, to] = r.key.split("->");
+      if (from !== void 0) bump(from.slice(prefix.length), r.seq);
+      if (to !== void 0) bump(to.slice(prefix.length), r.seq);
+    }
+  }
+  return out;
+}
+function stateTask(row, activity) {
+  return {
+    id: row.name,
+    title: row.title,
+    status: row.status,
+    substate: row.substate,
+    impact: row.impact,
+    effort_days: row.effortDays,
+    owner: row.status === "IN_PROGRESS" ? row.ownerName : null,
+    kind: row.kind,
+    wave: row.wave,
+    updated_at: row.updatedAt,
+    activity_seq: activity.get(row.name) ?? 0
+  };
+}
+function byActivityDesc(a, b) {
+  if (a.activity_seq !== b.activity_seq) return b.activity_seq - a.activity_seq;
+  if (a.updated_at !== b.updated_at) return a.updated_at < b.updated_at ? 1 : -1;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+var FINISHED_CALL = ["done", "failed", "cancelled"];
+function delegatesOf(db, workstream, caller) {
+  if (caller === null) return { delegates: [], waves: [] };
+  const calls = listDelegates(db, caller, workstream);
+  const delegates = calls.filter((c) => !FINISHED_CALL.includes(c.state)).map((c) => ({
+    call_id: c.callId,
+    task: c.task,
+    state: c.state,
+    wave: c.wave,
+    judges: c.record ? `${c.record.workstream}/${c.record.task}` : null,
+    agent: c.agent,
+    verdict: c.verdict,
+    error: c.error,
+    updated_at: c.updatedAt
+  }));
+  const labels = [...new Set(calls.flatMap((c) => c.wave === null ? [] : [c.wave]))].reverse();
+  const waves = labels.map((wave) => waveOf(verdictTally(db, workstream, wave, [caller]), wave));
+  return { delegates, waves };
+}
+function waveOf(t, wave) {
+  const sum = (k) => t.findings.reduce((n, f) => n + f[k], 0);
+  const w = {
+    wave,
+    confirmed: sum("confirmed"),
+    refuted: sum("refuted"),
+    unverified: sum("unverified"),
+    pending: sum("pending")
+  };
+  return {
+    ...w,
+    calls: w.confirmed + w.refuted + w.unverified + w.pending,
+    queued: t.queued,
+    running: t.running,
+    refused: t.refused
+  };
+}
+function countsOf(db, wsId) {
+  const n = (sql) => db.prepare(sql).get(wsId).n;
+  const by = (cond) => n(`SELECT count(*) AS n FROM tasks WHERE workstream_id = ? AND ${cond}`);
+  return {
+    tasks: by("1 = 1"),
+    open: by("status = 'OPEN'"),
+    parked: by("status = 'OPEN' AND substate = 'parked'"),
+    triage: by("status = 'OPEN' AND substate = 'triage'"),
+    ready: n("SELECT count(*) AS n FROM ready WHERE workstream_id = ?"),
+    blocked: n("SELECT count(*) AS n FROM blocked WHERE workstream_id = ?"),
+    in_progress: by("status = 'IN_PROGRESS'"),
+    closed: by("status = 'CLOSED'")
+  };
+}
+async function meOf(db, caller, self) {
+  if (self === null) return { caller: caller ?? "", agent: null, owned_tasks: [] };
+  const ws = self.workstreamName;
+  const wsRow = db.prepare("SELECT id, torn_down_at FROM workstreams WHERE name = ?").get(ws);
+  const [live] = await readLiveAgents(db, ws, self.name);
+  const live_ = live === void 0 ? null : liveAgentToOutput(live, wsRow?.id ?? 0);
+  const alive = wsRow !== void 0 && wsRow.torn_down_at === null;
+  const activity = alive ? taskActivity(db, ws) : /* @__PURE__ */ new Map();
+  return {
+    caller: caller ?? `${ws}/${self.name}`,
+    agent: live_,
+    owned_tasks: alive ? listTasksByOwner(db, ws, self.name).map((r) => stateTask(r, activity)).sort(byActivityDesc) : []
+  };
+}
+function callerWorkstreams(db, caller) {
+  const live = new Set(
+    db.prepare("SELECT name FROM workstreams WHERE torn_down_at IS NULL").all().map((r) => r.name)
+  );
+  const names = /* @__PURE__ */ new Set([
+    ...listDelegates(db, caller).map((c) => c.workstream),
+    ...openHumanNeeds(db, caller).map((h) => h.workstream)
+  ]);
+  return [...names].filter((n) => live.has(n)).sort();
+}
+async function stateSnapshot(db, opts) {
+  const needs = opts.caller === null ? [] : openHumanNeeds(db, opts.caller);
+  const workstreams = [];
+  let me = null;
+  for (const ws of opts.workstreams) {
+    const wsId = tryResolveLiveWorkstreamId(db, ws);
+    if (wsId === null) throw new WorkstreamNotFoundError(ws);
+    const activity = taskActivity(db, ws);
+    const task = (r) => stateTask(r, activity);
+    const state = {
+      workstream: ws,
+      workstream_id: wsId,
+      counts: countsOf(db, wsId),
+      ready: listReady(db, ws).sort(byRoiDesc).map(task),
+      ...delegatesOf(db, ws, opts.caller),
+      human_needs: needs.filter((h) => h.workstream === ws).map((h) => ({ id: h.id, reason: h.reason }))
+    };
+    if (opts.me === void 0) {
+      state.in_progress = listInProgress(db, ws).map(task).sort(byActivityDesc);
+      state.blocked = listBlocked(db, ws).map(task).sort(byActivityDesc);
+      state.triage = listTasks(db, ws, { status: "OPEN", substate: "triage" }).map(task).sort(byActivityDesc);
+      state.recent_closed = listTasks(db, ws, { status: "CLOSED" }).map(task).sort(byActivityDesc).slice(0, RECENT_CLOSED);
+      state.agents = (await readLiveAgents(db, ws)).map((a) => liveAgentToOutput(a, wsId));
+      const { tasks, open, in_progress } = state.counts;
+      const unfinished = open + in_progress;
+      if (tasks >= BIG_WORKSTREAM_TASKS && unfinished * 10 < tasks) {
+        state.hint = `${tasks} tasks, ${unfinished} open; start the next effort in a new <project>-<purpose> workstream`;
+      }
+    }
+    workstreams.push(state);
+  }
+  if (opts.me !== void 0) me = await meOf(db, opts.caller, opts.me.agent);
+  return { caller: opts.caller, me, workstreams };
+}
+
+// src/wait-resume.ts
+import { randomBytes } from "crypto";
+var RESUME_KEEP_DAYS = 14;
+var WaitResumeNotFoundError = class extends Error {
+  constructor(resumeId) {
+    super(say("wait.resume_not_found", resumeId, RESUME_KEEP_DAYS));
+    this.resumeId = resumeId;
+  }
+  resumeId;
+  name = "WaitResumeNotFoundError";
+};
+function saveResume(db, callers, spec) {
+  const now = /* @__PURE__ */ new Date();
+  const cutoff = new Date(now.getTime() - RESUME_KEEP_DAYS * 864e5).toISOString();
+  for (let attempt = 0; ; attempt++) {
+    const id = randomBytes(5).toString("hex");
+    try {
+      db.transaction(() => {
+        db.prepare("DELETE FROM wait_resumes WHERE created_at < ?").run(cutoff);
+        db.prepare(
+          "INSERT INTO wait_resumes (id, callers_json, spec_json, created_at) VALUES (?, ?, ?, ?)"
+        ).run(id, JSON.stringify(callers), JSON.stringify(spec), now.toISOString());
+      }).immediate();
+      return id;
+    } catch (e) {
+      if (attempt < 3 && /UNIQUE|PRIMARY KEY/i.test(String(e))) continue;
+      throw e;
+    }
+  }
+}
+function loadResume(db, id) {
+  const row = db.prepare("SELECT callers_json AS callers, spec_json AS spec FROM wait_resumes WHERE id = ?").get(id);
+  if (row === void 0) throw new WaitResumeNotFoundError(id);
+  try {
+    const callers = JSON.parse(row.callers);
+    const spec = JSON.parse(row.spec);
+    if (!Array.isArray(callers) || !Array.isArray(spec.refs)) throw new Error("bad shape");
+    return { id, callers, spec };
+  } catch {
+    throw new WaitRefError(`wait resume handle ${id} is unreadable (its stored row is damaged)`);
+  }
+}
+
+export {
+  RebuildTargetExistsError,
+  RebuildTargetIsSourceError,
+  rebuildInto,
+  DRIFT_REPORT_CAP,
+  checkCheapDriftInvariant,
+  checkDrift,
+  formatDriftRecord,
+  driftRemediation,
+  DriftDetectedError,
+  HazardFailError,
+  DbInsideSyncDirError,
+  isPathInside,
+  checkDbInsideSyncDir,
+  classifyFsType,
+  probeFilesystem,
+  checkNetworkMount,
+  findCaseCollisions,
+  checkCaseCollisions,
+  checkFleetHazards,
+  checkSegmentVersion,
+  checkOrphanedAgents,
+  checkCloseGuards,
+  checkUnpublishedOps,
+  AGENT_STATE_GLYPH,
+  agentStateGlyph,
+  GLYPH,
+  WAIT_HEARTBEAT_CAP_MS,
+  DEFAULT_STUCK_AFTER_MS,
+  DEFAULT_CTL_STUCK_AFTER_MS,
+  WaitNothingError,
+  WaveNotFoundError,
+  WaitRefError,
+  WAIT_REGEX_MAX_LEN,
+  WAIT_TEXT_MAX,
+  WaitRegexError,
+  checkRegexGrammar,
+  compileTextMatcher,
+  waitForEvents,
+  getActionReceipt,
+  reserveActionReceipt,
+  transitionActionReceipt,
+  releaseStall,
+  releaseStallHandler,
+  steerText,
+  steerStall,
+  steerStallHandler,
+  waitWithActions,
+  ctlAgentHooks,
+  NextArgError,
+  DEFAULT_NEXT_CAP,
+  MAX_NEXT_CAP,
+  executeNext,
+  MU_SHIM_MARKER,
+  skillDirDigest,
+  migratePi,
+  RemoteCollectUnsupportedError,
+  RemoteCollectError,
+  collectRef,
+  collectRemoteAgent,
+  TASK_SORT_KEYS,
+  isTaskSortKey,
+  byRoiDesc,
+  sortTasks,
+  relTimeBasisForSort,
+  callerWorkstreams,
+  stateSnapshot,
+  WaitResumeNotFoundError,
+  saveResume,
+  loadResume
+};
+//# sourceMappingURL=chunk-5HECDBK3.js.map