@mu-crew/mu 3.8.0 → 3.9.0

package/dist/index.js

@@ -151,7 +151,7 @@ import { dirname as dirname2, join as join2 } from "path";
 import { randomUUID } from "crypto";
 import { mkdirSync } from "fs";
 import { homedir, hostname } from "os";
-import { dirname, join, resolve } from "path";
+import { dirname, isAbsolute, join, resolve } from "path";
 import Database from "better-sqlite3";
 
 // src/capture.ts
@@ -257,6 +257,23 @@ var CAPTURED_COLUMNS = {
   task_notes: ["author", "content", "created_at"],
   task_edges: ["created_at"]
 };
+var KEY_COLUMNS = {
+  workstreams: ["name"],
+  tasks: ["workstream_id", "local_id"],
+  task_notes: ["id", "task_id"],
+  task_edges: ["from_task_id", "to_task_id"]
+};
+function keyGuard(table) {
+  const cols = KEY_COLUMNS[table];
+  const msg = `mu: ${table}.${cols.join("/")} is part of the natural key that every op is filed under; changing it would desync the ops log, sync and undo. Add a new row (mu task add / mu workstream init) instead of moving or renaming one.`;
+  return `
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_${table}_key
+BEFORE UPDATE OF ${cols.join(", ")} ON ${table}
+  WHEN ${anyChanged(cols)}
+BEGIN
+  SELECT RAISE(ABORT, '${msg.replaceAll("'", "''")}');
+END;`;
+}
 var DYING_STASH = (kind, keyExpr) => `INSERT OR REPLACE INTO _op_dying (kind, id, key) VALUES ('${kind}', OLD.id, ${keyExpr});`;
 function buildTriggerDdl() {
   const wsCols = CAPTURED_COLUMNS.workstreams;
@@ -268,6 +285,12 @@ function buildTriggerDdl() {
   const edgeKeyNew = `${taskKey("NEW.from_task_id")} || '->' || ${taskKey("NEW.to_task_id")}`;
   const edgeKeyOld = `${taskKey("OLD.from_task_id")} || '->' || ${taskKey("OLD.to_task_id")}`;
   return `
+-- \u2500\u2500\u2500 natural-key guards (see KEY_COLUMNS) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${keyGuard("workstreams")}
+${keyGuard("tasks")}
+${keyGuard("task_notes")}
+${keyGuard("task_edges")}
+
 -- \u2500\u2500\u2500 workstreams \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 CREATE TEMP TRIGGER IF NOT EXISTS _cap_workstreams_ins
 AFTER INSERT ON workstreams WHEN ${NOT_APPLYING}
@@ -403,8 +426,11 @@ function formatPair(pair) {
 // src/db.ts
 function defaultStateDir() {
   if (process.env.MU_STATE_DIR) return process.env.MU_STATE_DIR;
-  const stateHome = process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
-  return join(stateHome, "mu");
+  return join(xdgStateHome(homedir()), "mu");
+}
+function xdgStateHome(home) {
+  const xdg = process.env.XDG_STATE_HOME;
+  return xdg !== void 0 && isAbsolute(xdg) ? xdg : join(home, ".local", "state");
 }
 function defaultDbPath() {
   if (process.env.MU_DB_PATH) return process.env.MU_DB_PATH;
@@ -416,8 +442,6 @@ function openDb(options = {}) {
   mkdirSync(dirname(path), { recursive: true });
   const db = new Database(path, { readonly: options.readonly ?? false });
   if (!options.readonly) {
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
     db.pragma("busy_timeout = 5000");
     const detectedVersion = detectExistingSchemaVersion(db);
     if (detectedVersion !== null && detectedVersion > CURRENT_SCHEMA_VERSION) {
@@ -434,6 +458,8 @@ function openDb(options = {}) {
       }
       throw new SchemaTooOldError(detectedVersion, MIN_ACCEPTED_SCHEMA_VERSION);
     }
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
     applySchema(db);
     seedMachineIdentity(db);
     installCapture(db);
@@ -446,8 +472,7 @@ function refuseUserDbDuringTests(path) {
   const inTest = process.env.VITEST !== void 0 || process.env.NODE_ENV === "test";
   if (!inTest) return;
   const home = process.env.HOME ?? homedir();
-  const xdg = process.env.XDG_STATE_HOME ?? join(home, ".local", "state");
-  const realDb = resolve(join(xdg, "mu", "mu.db"));
+  const realDb = resolve(join(xdgStateHome(home), "mu", "mu.db"));
   if (resolve(path) === realDb) {
     throw new Error(
       `openDb refused: tests must NEVER write to the user DB (${realDb}). Set MU_DB_PATH to a per-test temp path (test/_runCli.ts does this automatically) or pass an explicit { path } argument. The leak source is the call site of openDb in this stack frame.`
@@ -502,7 +527,7 @@ var SchemaTooOldError = class extends Error {
         command: `mv "\${MU_DB_PATH:-$HOME/.local/state/mu/mu.db}" "\${MU_DB_PATH:-$HOME/.local/state/mu/mu.db}.old"`
       },
       {
-        intent: `Migrate the old DB into a fresh v${this.requiredVersion} DB`,
+        intent: `Migrate the old DB into a fresh v${this.requiredVersion} DB (run in a mu git checkout: the npm package does not ship scripts/)`,
         command: `npx tsx scripts/migrate.ts "\${MU_DB_PATH:-$HOME/.local/state/mu/mu.db}.old" --out /tmp/mu-v${this.requiredVersion}.db`
       },
       {
@@ -810,6 +835,7 @@ CREATE INDEX IF NOT EXISTS idx_ops_group ON ops (group_id);
 -- into that peer's segment we have applied. One integer suffices
 -- because segments are append-only and ordered. Rows are created on
 -- demand at first ingest; there is no membership list to configure.
+-- A Syncthing conflict copy gets its own row, keyed by its file stem.
 CREATE TABLE IF NOT EXISTS sync_peers (
   machine_id       TEXT PRIMARY KEY,
   last_applied_seq INTEGER NOT NULL DEFAULT 0,
@@ -976,6 +1002,9 @@ var LEGACY_LOG_ONLY_INTENTS = /* @__PURE__ */ new Set(["workstream.export"]);
 function isLegacyLogOnlyIntent(intent) {
   return intent !== null && LEGACY_LOG_ONLY_INTENTS.has(intent);
 }
+var LEGACY_LOG_ONLY_SQL_EXCLUSION = `(intent IS NULL OR intent NOT IN (${[
+  ...LEGACY_LOG_ONLY_INTENTS
+].map((i) => `'${i}'`).join(", ")}))`;
 var LEGACY_INTENT_SYNONYMS = /* @__PURE__ */ new Map([
   ["workstream.teardown", ["workstream.destroy"]]
 ]);
@@ -983,9 +1012,6 @@ function intentSpellings(intent) {
   const legacy = LEGACY_INTENT_SYNONYMS.get(intent);
   return legacy === void 0 ? [intent] : [intent, ...legacy];
 }
-var LEGACY_LOG_ONLY_SQL_EXCLUSION = `(intent IS NULL OR intent NOT IN (${[
-  ...LEGACY_LOG_ONLY_INTENTS
-].map((i) => `'${i}'`).join(", ")}))`;
 
 // src/logs.ts
 var SELECT_LOG_COLS = `
@@ -1068,8 +1094,30 @@ function rowFromDb(row) {
     createdAt: row.created_at
   };
 }
+var RESERVED_LOG_KINDS = new Set(
+  SYNCED_ENTITIES.filter((e) => e !== "message")
+);
+var LogKindReservedError = class extends Error {
+  constructor(kind) {
+    super(
+      `--kind ${JSON.stringify(kind)} is reserved: ${[...RESERVED_LOG_KINDS].join(", ")} name projectable op entities, and a log line under one would be synced and replayed as a real ${kind} change`
+    );
+    this.kind = kind;
+  }
+  kind;
+  name = "LogKindReservedError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "Use a channel tag that names your ledger",
+        command: `mu log --kind ${this.kind}-log '<text>'`
+      }
+    ];
+  }
+};
 function appendLog(db, opts) {
   const kind = opts.kind ?? "message";
+  if (RESERVED_LOG_KINDS.has(kind)) throw new LogKindReservedError(kind);
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   const key = opts.workstream ?? MACHINE_WIDE_KEY;
   const group = randomUUID2();
@@ -1113,7 +1161,10 @@ function listLogs(db, opts = {}) {
     conditions.push("l.seq > ?");
     params.push(opts.since);
   }
-  if (opts.source !== void 0) {
+  if (opts.source === "system") {
+    conditions.push("(l.actor = ? OR l.actor IS NULL)");
+    params.push(opts.source);
+  } else if (opts.source !== void 0) {
     conditions.push("l.actor = ?");
     params.push(opts.source);
   }
@@ -1355,19 +1406,26 @@ function resetSleep() {
 function sleep(ms) {
   return currentSleep(ms);
 }
+function exactSessionTarget(name) {
+  return `=${name}:`;
+}
+var NO_SERVER_RE = /no server running|error connecting to .*\(No such file or directory\)/i;
+function isPaneGoneError(err) {
+  return err instanceof TmuxError && (/can't find pane|pane not found|no current target/i.test(err.stderr) || NO_SERVER_RE.test(err.stderr));
+}
 async function listSessions() {
   try {
     const out = await tmux(["list-sessions", "-F", "#{session_name}"]);
     return out.split("\n").filter((line) => line.length > 0).map((name) => ({ name }));
   } catch (err) {
-    if (err instanceof TmuxError && /no server running|no sessions/i.test(err.stderr)) {
+    if (err instanceof TmuxError && (NO_SERVER_RE.test(err.stderr) || /no sessions/i.test(err.stderr))) {
       return [];
     }
     throw err;
   }
 }
 async function sessionExists(name) {
-  const result = await currentExecutor(["has-session", "-t", name]);
+  const result = await currentExecutor(["has-session", "-t", exactSessionTarget(name)]);
   return result.exitCode === 0;
 }
 async function newSession(name, opts = {}) {
@@ -1392,19 +1450,21 @@ async function newSessionWithPane(name, opts) {
   return out;
 }
 async function killSession(name) {
-  const result = await currentExecutor(["kill-session", "-t", name]);
-  if (result.exitCode !== 0 && !/can't find session|session not found|no server running|no current target/i.test(result.stderr)) {
-    throw new TmuxError(
-      ["kill-session", "-t", name],
-      result.stderr,
-      result.stdout,
-      result.exitCode
-    );
+  const args = ["kill-session", "-t", exactSessionTarget(name)];
+  const result = await currentExecutor(args);
+  if (result.exitCode !== 0 && !/can't find session|session not found|no current target/i.test(result.stderr) && !NO_SERVER_RE.test(result.stderr)) {
+    throw new TmuxError(args, result.stderr, result.stdout, result.exitCode);
   }
 }
 async function listWindows(session) {
   if (session) {
-    const out2 = await tmux(["list-windows", "-t", session, "-F", "#{window_id}	#{window_name}"]);
+    const out2 = await tmux([
+      "list-windows",
+      "-t",
+      exactSessionTarget(session),
+      "-F",
+      "#{window_id}	#{window_name}"
+    ]);
     return parseWindows(out2);
   }
   const out = await tmux([
@@ -1435,7 +1495,7 @@ function parseWindows(output) {
 async function newWindow(opts) {
   const args = ["new-window"];
   if (opts.detached !== false) args.push("-d");
-  if (opts.session) args.push("-t", opts.session);
+  if (opts.session) args.push("-t", exactSessionTarget(opts.session));
   args.push("-n", opts.name);
   if (opts.cwd) args.push("-c", opts.cwd);
   appendEnvFlags(args, opts.env);
@@ -1449,15 +1509,13 @@ async function listPanesInSession(session) {
     "list-panes",
     "-s",
     "-t",
-    session,
+    exactSessionTarget(session),
     "-F",
     "#{window_id}	#{pane_id}	#{pane_title}	#{pane_current_command}"
   ];
   const result = await currentExecutor(args);
   if (result.exitCode !== 0) {
-    if (/can't find (session|window)|no server running|no sessions|no current target/i.test(
-      result.stderr
-    )) {
+    if (/can't find (session|window)|no sessions|no current target/i.test(result.stderr) || NO_SERVER_RE.test(result.stderr)) {
       return [];
     }
     throw new TmuxError(args, result.stderr, result.stdout, result.exitCode);
@@ -1528,7 +1586,7 @@ function appendEnvFlags(args, env) {
 async function killPane(paneId) {
   assertValidPaneId(paneId);
   const result = await currentExecutor(["kill-pane", "-t", paneId]);
-  if (result.exitCode !== 0 && !/can't find pane/i.test(result.stderr)) {
+  if (result.exitCode !== 0 && !/can't find pane/i.test(result.stderr) && !NO_SERVER_RE.test(result.stderr)) {
     throw new TmuxError(["kill-pane", "-t", paneId], result.stderr, result.stdout, result.exitCode);
   }
 }
@@ -1582,7 +1640,7 @@ async function paneTTY(paneId) {
   assertValidPaneId(paneId);
   const result = await currentExecutor(["display-message", "-t", paneId, "-p", "#{pane_tty}"]);
   if (result.exitCode !== 0) {
-    if (/can't find pane|pane not found/i.test(result.stderr)) {
+    if (/can't find pane|pane not found/i.test(result.stderr) || NO_SERVER_RE.test(result.stderr)) {
       throw new PaneNotFoundError(paneId, tmuxBackend);
     }
     throw new TmuxError(
@@ -1645,7 +1703,10 @@ async function awaitPaneQuiescence(paneId, budgetMs) {
   const deadline = Date.now() + budgetMs;
   let calm = 0;
   for (; ; ) {
-    const scrollback = await capturePane(paneId, { lines: 50 }).catch(() => void 0);
+    const scrollback = await capturePane(paneId, { lines: 50 }).catch((err) => {
+      if (isPaneGoneError(err)) throw err;
+      return void 0;
+    });
     const busy = scrollback === void 0 || paneLooksBusy(scrollback);
     if (busy && scrollback !== void 0 && hasWorkMarker(scrollback)) return true;
     if (!busy) {
@@ -1730,9 +1791,19 @@ async function capturePane(paneId, opts = {}) {
     args.push("-S", "-", "-E", "-");
   } else if (opts.lines > 0) {
     args.push("-S", `-${opts.lines}`);
+    return lastLines(await tmux(args), opts.lines);
   }
   return tmux(args);
 }
+function lastLines(text, n) {
+  const lines = text.split("\n");
+  let end = lines.length;
+  while (end > 0 && (lines[end - 1] ?? "").trim() === "") end--;
+  if (end === 0) return "";
+  const kept = lines.slice(Math.max(0, end - n), end).join("\n");
+  return text.endsWith("\n") ? `${kept}
+` : kept;
+}
 async function tmuxAvailable() {
   try {
     await tmux(["-V"]);
@@ -1827,7 +1898,7 @@ var tmuxBackend = Object.freeze({
 // src/mux/herdr.ts
 var HerdrError = class extends MuxError {
   constructor(args, stderr, stdout, exitCode, code) {
-    const detail = parseErrorEnvelope(stderr)?.message ?? stderr.trim() ?? stdout.trim();
+    const detail = parseErrorEnvelope(stderr)?.message ?? (stderr.trim() || stdout.trim());
     super(`herdr ${args.join(" ")} failed (exit ${exitCode}): ${detail || "no output"}`);
     this.args = args;
     this.stderr = stderr;
@@ -1958,8 +2029,10 @@ var HerdrWorkspaceGroupCloseError = class extends Error {
 };
 var HerdrNotImplementedError = class extends Error {
   name = "HerdrNotImplementedError";
-  constructor(method, owner) {
-    super(`herdr backend: ${method} is not implemented yet (owned by task ${owner})`);
+  constructor(method) {
+    super(
+      `herdr backend: ${method} is not supported: herdr creation verbs always start a plain shell; create the pane without a command, then start the agent with startAgentInPane`
+    );
   }
 };
 var HERDR_ORDINAL = "[0-9A-Z]+";
@@ -2078,10 +2151,12 @@ function readPane(v) {
     // herdr's optional `label` is what `pane rename` writes and is
     // therefore mu's pane-title equivalent.
     title: asString(v.label) ?? "",
-    // herdr does not report a foreground command on `pane list`; the
-    // authoritative answer costs a `pane process-info` round trip per
-    // pane. Callers that need it use `paneCommand()`.
-    command: "",
+    // herdr reports no foreground command on `pane list` (that costs a
+    // `pane process-info` round trip per pane), but it does report the
+    // agent kind it detected (`pi`, `claude`, `codex`, ...). That is
+    // what `command` is used for: reconcile's orphan recogniser matches
+    // it against the agent CLIs. Empty for a plain shell.
+    command: asString(v.agent) ?? "",
     windowId: asString(v.tab_id)
   };
 }
@@ -2128,7 +2203,7 @@ async function newSession2(name, opts = {}) {
   const args = ["workspace", "create", "--label", name, "--no-focus"];
   if (opts.cwd) args.push("--cwd", opts.cwd);
   appendEnvFlags2(args, opts.env);
-  await herdr(args);
+  await labelRootTab(await herdr(args), opts.windowName);
 }
 async function newSessionWithPane2(name, opts) {
   rejectCommand("newSessionWithPane", opts.command);
@@ -2136,7 +2211,39 @@ async function newSessionWithPane2(name, opts) {
   if (opts.cwd) args.push("--cwd", opts.cwd);
   appendEnvFlags2(args, opts.env);
   const result = await herdr(args);
-  return readCreatedPaneId(result, "root_pane", args);
+  const paneId = readCreatedPaneId(result, "root_pane", args);
+  await labelRootTab(result, opts.windowName);
+  return paneId;
+}
+async function labelRootTab(created, windowName) {
+  if (windowName === void 0 || windowName.length === 0) return;
+  const root = created.root_pane;
+  const tab = created.tab;
+  const tabId = (isRecord(root) ? asString(root.tab_id) : void 0) ?? (isRecord(tab) ? asString(tab.tab_id) : void 0);
+  try {
+    if (tabId === void 0) {
+      throw new HerdrError(
+        ["workspace", "create"],
+        `herdr response had no root tab id: ${JSON.stringify(created)}`,
+        "",
+        0
+      );
+    }
+    await herdr(["tab", "rename", tabId, windowName]);
+  } catch (err) {
+    await closeCreatedWorkspace(created);
+    throw err;
+  }
+}
+async function closeCreatedWorkspace(created) {
+  const ws = created.workspace;
+  const root = created.root_pane;
+  const id = (isRecord(ws) ? asString(ws.workspace_id) : void 0) ?? (isRecord(root) ? asString(root.workspace_id) : void 0);
+  if (id === void 0) return;
+  try {
+    await herdrTolerating(["workspace", "close", id], ["workspace_not_found"]);
+  } catch {
+  }
 }
 async function killSession2(name) {
   const id = await resolveWorkspaceId(name);
@@ -2265,10 +2372,10 @@ async function paneTTY2(paneId) {
     ["pane", "process-info", "--pane", paneId],
     ["pane_not_found", "workspace_not_found"]
   );
-  if (result === void 0) throw new PaneNotFoundError(paneId);
+  if (result === void 0) throw new PaneNotFoundError(paneId, herdrBackend);
   const info = result.process_info;
   const pid = isRecord(info) ? info.shell_pid : void 0;
-  if (typeof pid !== "number") throw new PaneNotFoundError(paneId);
+  if (typeof pid !== "number") throw new PaneNotFoundError(paneId, herdrBackend);
   const { readlink } = await import("fs/promises");
   try {
     return await readlink(`/proc/${pid}/fd/0`);
@@ -2426,7 +2533,7 @@ function appendEnvFlags2(args, env) {
 }
 function rejectCommand(method, command) {
   if (command === void 0 || command.trim().length === 0) return;
-  throw new HerdrNotImplementedError(`${method} with a command`, "mux-herdr-spawn");
+  throw new HerdrNotImplementedError(`${method} with a command`);
 }
 function readCreatedPaneId(result, key, args) {
   const pane = readPane(result[key]);
@@ -2451,14 +2558,32 @@ async function herdrAvailable() {
   if (result === void 0 || result.exitCode !== 0) return false;
   return isHerdrStatusUsable(result.stdout);
 }
-function attachHint2(target) {
+async function attachFocusArgs(workspaceId, target) {
   if (target.window !== void 0) {
-    return `herdr session attach ${target.session} # then focus tab ${target.window}`;
+    const tabs = readTabs(await herdr(["tab", "list", "--workspace", workspaceId]));
+    const tab = tabs.find((t) => t.name === target.window);
+    if (tab !== void 0) return ["tab", "focus", tab.id];
+  }
+  return ["workspace", "focus", workspaceId];
+}
+function insideHerdrClient() {
+  return process.env.HERDR_ENV === "1";
+}
+async function attachHint2(target) {
+  const base = ["herdr", ...herdrGlobalFlags()].join(" ");
+  const focus = await resolveWorkspaceId(target.session).then((id) => id === void 0 ? void 0 : attachFocusArgs(id, target)).catch(() => void 0);
+  if (focus === void 0) {
+    return `${base} workspace list  # then: ${base} workspace focus <id of ${target.session}>`;
   }
-  return `herdr session attach ${target.session}`;
+  const line = `${base} ${focus.join(" ")}`;
+  return insideHerdrClient() ? line : `${line} && ${base}`;
 }
-function attachCommands2(target) {
-  return [{ command: "herdr", args: ["session", "attach", target.session] }];
+async function attachCommands2(target) {
+  const flags = herdrGlobalFlags();
+  const focus = await attachFocusArgs(await requireWorkspaceId(target.session), target);
+  const steps = [{ command: "herdr", args: [...flags, ...focus] }];
+  if (!insideHerdrClient()) steps.push({ command: "herdr", args: [...flags] });
+  return steps;
 }
 function paneNotFoundNextSteps2(paneId) {
   return [
@@ -2815,16 +2940,11 @@ var WorkspacePathNotEmptyError = class extends Error {
         command: `mu workspace orphans -w ${this.workstream}`
       },
       {
-        intent: "If the dir is intentional (orphan from older mu), free it via mu first",
-        command: `mu workspace free ${this.agent} -w ${this.workstream}  # also runs backend cleanup if a row remains`
-      },
-      {
-        intent: "Or delete it manually if the registry has no row",
-        command: `rm -rf ${this.workspacePath}`
-      },
-      {
-        intent: "For git workspaces specifically: also prune the worktree registration",
-        command: "cd <project-root> && git worktree prune"
+        // No row points at the dir (createWorkspace throws
+        // WorkspaceExistsError first when one does), so `mu workspace
+        // free` has nothing to free. Same recipe as `mu workspace orphans`.
+        intent: "Inspect it, then remove it by hand (git: also drops the worktree registration)",
+        command: `(cd <project-root> && git worktree remove --force ${this.workspacePath}) || rm -rf ${this.workspacePath}`
       }
     ];
   }
@@ -2937,22 +3057,44 @@ var WorkspaceDirtyError = class extends Error {
   }
 };
 var WorkspaceConflictError = class extends Error {
-  constructor(workspacePath2, fromRef, conflicts) {
-    super(`rebase onto ${fromRef} produced ${conflicts.length} conflict(s): ${workspacePath2}`);
+  constructor(workspacePath2, fromRef, conflicts, aborted = true) {
+    super(
+      `rebase onto ${fromRef} produced ${conflicts.length} conflict(s)${aborted ? "; rebase aborted, workspace unchanged" : "; conflicts left in place"}: ${workspacePath2}`
+    );
     this.workspacePath = workspacePath2;
     this.fromRef = fromRef;
     this.conflicts = conflicts;
+    this.aborted = aborted;
   }
   workspacePath;
   fromRef;
   conflicts;
+  aborted;
   name = "WorkspaceConflictError";
   errorNextSteps() {
+    const resync = {
+      intent: "After resolving, record the new base (a clean refresh updates the fork point)",
+      command: `mu workspace refresh <agent> --from '${this.fromRef}'`
+    };
+    if (this.aborted) {
+      return [
+        {
+          intent: "The rebase was aborted. Rebase by hand in the workspace and resolve",
+          command: `cd ${this.workspacePath}  # then: git rebase ${this.fromRef}  (sl: sl rebase -d '${this.fromRef}')`
+        },
+        resync,
+        {
+          intent: "Or DISCARD the workspace entirely (the lossy escape)",
+          command: "mu workspace free <agent>"
+        }
+      ];
+    }
     return [
       {
-        intent: "cd into the workspace and resolve",
-        command: `cd ${this.workspacePath}  # then resolve & commit; or: git rebase --abort / jj abandon / sl rebase --abort`
-      }
+        intent: "Resolve the conflicted commits in place",
+        command: `cd ${this.workspacePath}  # then: jj resolve; or undo the rebase: jj op undo`
+      },
+      resync
     ];
   }
 };
@@ -2992,26 +3134,38 @@ async function run(bin, args, cwd) {
   }
 }
 async function runShow(bin, args, cwd) {
+  let stdout;
+  let overflowed = false;
   try {
-    const { stdout } = await exec(bin, [...args], {
-      cwd,
-      maxBuffer: SHOW_COMMIT_MAX_CHARS * 2
-    });
-    if (stdout.length > SHOW_COMMIT_MAX_CHARS) {
+    ({ stdout } = await exec(bin, [...args], { cwd, maxBuffer: SHOW_COMMIT_MAX_CHARS * 2 }));
+  } catch (err) {
+    const partial = stdoutOverflow(err);
+    if (partial === void 0) {
       return {
-        text: `${stdout.slice(0, SHOW_COMMIT_MAX_CHARS)}
-\u2026(truncated at ${SHOW_COMMIT_MAX_CHARS} chars)`,
-        truncated: true
+        text: "",
+        truncated: false,
+        error: err instanceof Error ? err.message : String(err)
       };
     }
-    return { text: stdout, truncated: false };
-  } catch (err) {
+    stdout = partial;
+    overflowed = true;
+  }
+  if (overflowed || stdout.length > SHOW_COMMIT_MAX_CHARS) {
     return {
-      text: "",
-      truncated: false,
-      error: err instanceof Error ? err.message : String(err)
+      text: `${stdout.slice(0, SHOW_COMMIT_MAX_CHARS)}
+\u2026(truncated at ${SHOW_COMMIT_MAX_CHARS} chars)`,
+      truncated: true
     };
   }
+  return { text: stdout, truncated: false };
+}
+function stdoutOverflow(err) {
+  if (!(err instanceof Error)) return void 0;
+  const e = err;
+  if (e.code !== "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || typeof e.stdout !== "string") {
+    return void 0;
+  }
+  return e.message.startsWith("stdout ") ? e.stdout : void 0;
 }
 function relTimeFromIso(iso) {
   const t = Date.parse(iso);
@@ -3104,15 +3258,15 @@ var gitBackend = {
   },
   // Rebase the worktree onto `fromRef` (default = origin/HEAD via
   // resolveGitMainRef). Refuses on a dirty WC; returns the replayed
-  // commit subjects oldest-first; on conflict aborts the rebase and
-  // throws WorkspaceConflictError so the operator never inherits a
-  // half-rebased worktree from us.
+  // commit subjects oldest-first and the new fork point (parentRef);
+  // on conflict aborts the rebase and throws WorkspaceConflictError so
+  // the operator never inherits a half-rebased worktree from us.
   //
   // We DO `git fetch` first — otherwise the rebase target would only
   // be as fresh as the local refs cache, and the operator running
   // `mu workspace refresh` is explicitly asking for the latest. This
   // is the one-and-only place mu fetches; commitsBehind() stays pure.
-  async rebaseTo(workspacePath2, fromRef) {
+  async rebaseTo(workspacePath2, fromRef, previousParentRef) {
     if (!existsSync2(workspacePath2)) {
       throw new Error(`vcs git: workspace path missing: ${workspacePath2}`);
     }
@@ -3134,7 +3288,7 @@ var gitBackend = {
       }
       resolvedRef = main;
     }
-    const preHead = await run("git", ["rev-parse", "HEAD"], workspacePath2);
+    const headBefore = await run("git", ["rev-parse", "HEAD"], workspacePath2);
     try {
       await run(
         "git",
@@ -3150,16 +3304,21 @@ var gitBackend = {
       }
       throw err;
     }
-    const mergeBase = await run("git", ["merge-base", "HEAD", resolvedRef], workspacePath2).catch(
-      () => preHead
+    const target = await run(
+      "git",
+      ["rev-parse", "--verify", `${resolvedRef}^{commit}`],
+      workspacePath2
     );
-    const logOut = await run(
+    const keepPrevious = previousParentRef !== void 0 && await gitIsAncestor(workspacePath2, target, previousParentRef) && await gitIsAncestor(workspacePath2, previousParentRef, "HEAD");
+    const parentRef = keepPrevious ? previousParentRef : target;
+    const headAfter = await run("git", ["rev-parse", "HEAD"], workspacePath2);
+    const logOut = headAfter === headBefore ? "" : await run(
       "git",
-      ["log", "--reverse", "--format=%s", `${mergeBase}..HEAD`],
+      ["log", "--reverse", "--format=%s", `${parentRef}..HEAD`],
       workspacePath2
     );
     const replayed = logOut.length === 0 ? [] : logOut.split("\n");
-    return { fromRef: resolvedRef, replayed, conflicts: [] };
+    return { fromRef: resolvedRef, parentRef, replayed, conflicts: [] };
   },
   // List commits in (baseRef..HEAD), oldest-first. The format string
   // packs four NUL-delimited fields per record, then a record
@@ -3210,6 +3369,7 @@ var gitBackend = {
       return { removed: false };
     }
     let committedRef;
+    let branch;
     if (opts.commit) {
       const dirty = (await listGitDirtyFiles(opts.workspacePath)).length > 0;
       if (dirty) {
@@ -3229,6 +3389,7 @@ var gitBackend = {
         );
         committedRef = await run("git", ["rev-parse", "HEAD"], opts.workspacePath);
       }
+      branch = await keepGitHeadReachable(opts.workspacePath);
     }
     const projectRoot = await resolveGitProjectRoot(opts.workspacePath);
     if (projectRoot) {
@@ -3238,6 +3399,7 @@ var gitBackend = {
     }
     const result = { removed: true };
     if (committedRef !== void 0) result.committedRef = committedRef;
+    if (branch !== void 0) result.branch = branch;
     return result;
   },
   async listDirtyFiles(workspacePath2) {
@@ -3245,6 +3407,14 @@ var gitBackend = {
     return listGitDirtyFiles(workspacePath2);
   }
 };
+async function gitIsAncestor(cwd, ancestor, descendant) {
+  try {
+    await run("git", ["merge-base", "--is-ancestor", ancestor, descendant], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function resolveGitMainRef(workspacePath2) {
   for (const candidate of [
     "refs/remotes/origin/HEAD",
@@ -3272,6 +3442,21 @@ async function listGitUnmergedPaths(workspacePath2) {
     return [];
   }
 }
+async function keepGitHeadReachable(workspacePath2) {
+  const containing = await run(
+    "git",
+    ["for-each-ref", "--count=1", "--contains", "HEAD", "refs/heads", "refs/remotes", "refs/tags"],
+    workspacePath2
+  );
+  if (containing.length > 0) return void 0;
+  const sha = await run("git", ["rev-parse", "HEAD"], workspacePath2);
+  const parts = workspacePath2.replace(/\/+$/, "").split("/");
+  const agent = parts.at(-1) ?? "workspace";
+  const workstream = parts.at(-2) ?? "mu";
+  const branch = `mu/${workstream}/${agent}-${sha.slice(0, 12)}`;
+  await run("git", ["branch", branch, sha], workspacePath2);
+  return branch;
+}
 async function resolveGitProjectRoot(workspacePath2) {
   try {
     const { stdout } = await exec(
@@ -3317,6 +3502,7 @@ var jjBackend = {
     }
     await ensureParent(opts.workspacePath);
     const name = jjWorkspaceName(opts.workspacePath);
+    await forgetIfRootMissing(name, opts.projectRoot);
     const args = ["workspace", "add", "--name", name];
     if (opts.parentRef) args.push("--revision", opts.parentRef);
     args.push(opts.workspacePath);
@@ -3328,7 +3514,6 @@ var jjBackend = {
     if (!existsSync3(opts.workspacePath)) {
       return { removed: false };
     }
-    const name = jjWorkspaceName(opts.workspacePath);
     let committedRef;
     if (opts.commit) {
       const desc = await run(
@@ -3351,7 +3536,7 @@ var jjBackend = {
       }
       committedRef = await jjCommitId(opts.workspacePath);
     }
-    await run("jj", ["workspace", "forget", name], opts.workspacePath);
+    await run("jj", ["workspace", "forget"], opts.workspacePath);
     rmDirSync(opts.workspacePath);
     const result = { removed: true };
     if (committedRef !== void 0) result.committedRef = committedRef;
@@ -3411,18 +3596,15 @@ var jjBackend = {
   // doesn't auto-abort on conflicts (they materialise as commits with
   // conflict markers), so the workspace is left in a state the
   // operator can resolve in-place.
-  async rebaseTo(workspacePath2, fromRef) {
+  async rebaseTo(workspacePath2, fromRef, previousParentRef) {
     if (!existsSync3(workspacePath2)) {
       throw new Error(`vcs jj: workspace path missing: ${workspacePath2}`);
     }
     const target = fromRef ?? "trunk()";
-    const preRev = await run(
-      "jj",
-      ["log", "-r", "@", "--no-graph", "--no-pager", "--color", "never", "--template", "change_id"],
-      workspacePath2
-    );
+    const headBefore = await jjCommitId(workspacePath2);
     await run("jj", ["rebase", "-d", target], workspacePath2);
-    const replayedRaw = await run(
+    const moved = await jjCommitId(workspacePath2) !== headBefore;
+    const replayedRaw = moved ? await run(
       "jj",
       [
         "log",
@@ -3437,7 +3619,7 @@ var jjBackend = {
         'description.first_line() ++ "\\n"'
       ],
       workspacePath2
-    ).catch(() => "");
+    ).catch(() => "") : "";
     const replayed = replayedRaw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
     const conflictRaw = await run(
       "jj",
@@ -3456,12 +3638,17 @@ var jjBackend = {
     ).catch(() => "");
     const conflicts = conflictRaw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
     if (conflicts.length > 0) {
-      throw new WorkspaceConflictError(workspacePath2, target, conflicts);
+      throw new WorkspaceConflictError(workspacePath2, target, conflicts, false);
     }
-    void preRev;
-    return { fromRef: target, replayed, conflicts: [] };
+    const targetId = await jjSingleCommitId(workspacePath2, target);
+    if (targetId === void 0) return { fromRef: target, replayed, conflicts: [] };
+    const keepPrevious = previousParentRef !== void 0 && await jjSingleCommitId(workspacePath2, `${previousParentRef} & ${targetId}:: & ::@`) !== void 0;
+    const parentRef = keepPrevious ? previousParentRef : targetId;
+    return { fromRef: target, parentRef, replayed, conflicts: [] };
   },
-  // List jj commits in (baseRef..@), oldest-first. jj's templating
+  // List jj commits in (baseRef..@), oldest-first, minus @ itself when
+  // it is the empty, undescribed working-copy commit jj snapshots on
+  // every command: that is "no work yet", not a commit. jj's templating
   // gives us per-field strings; we glue them with NUL field-separators
   // and \x1e record-separators so multi-line descriptions/bodies
   // round-trip cleanly. The author timestamp template is
@@ -3476,7 +3663,7 @@ var jjBackend = {
       [
         "log",
         "-r",
-        `${baseRef}..@`,
+        `(${baseRef}..@) ~ (@ & empty() & description(exact:""))`,
         "--no-graph",
         "--no-pager",
         "--color",
@@ -3527,7 +3714,46 @@ var jjBackend = {
 };
 var jjCommitSummaryTemplate = 'commit_id ++ "\\x00" ++ description.first_line() ++ "\\x00" ++ description ++ "\\x00" ++ author.timestamp().format("%Y-%m-%dT%H:%M:%S%:z") ++ "\\x00" ++ author.name() ++ "\\x1e"';
 function jjWorkspaceName(workspacePath2) {
-  return workspacePath2.replace(/\/+$/, "").split("/").pop() ?? workspacePath2;
+  const parts = workspacePath2.split("/").filter((p) => p.length > 0);
+  return parts.slice(-2).join("/") || workspacePath2;
+}
+async function forgetIfRootMissing(name, projectRoot) {
+  try {
+    const out = await run(
+      "jj",
+      [
+        "workspace",
+        "list",
+        "--color",
+        "never",
+        "--template",
+        'name ++ "\\x00" ++ self.root() ++ "\\x1e"'
+      ],
+      projectRoot
+    );
+    const stale = out.split("").map((r) => r.trim().split("\0")).some(([n, root]) => n === name && root === "");
+    if (stale) await run("jj", ["workspace", "forget", name], projectRoot);
+  } catch {
+  }
+}
+async function jjSingleCommitId(workspacePath2, revset) {
+  const out = await run(
+    "jj",
+    [
+      "log",
+      "-r",
+      revset,
+      "--no-graph",
+      "--no-pager",
+      "--color",
+      "never",
+      "--template",
+      'commit_id ++ "\\n"'
+    ],
+    workspacePath2
+  ).catch(() => "");
+  const ids = out.split("\n").filter((l) => l.length > 0);
+  return ids.length === 1 ? ids[0] : void 0;
 }
 async function jjCommitId(workspacePath2) {
   return run(
@@ -3671,12 +3897,15 @@ var slBackend = {
     }
   },
   // Rebase the active draft chain onto `fromRef` (default = `trunk()`).
-  // Sapling refuses on dirty WC by default — we pre-check and convert
-  // its error into the typed WorkspaceDirtyError. Conflict surface
-  // post-rebase via `sl resolve --list --tool=internal:dumpjson` is
-  // brittle across versions, so we use the textual `sl resolve --list`
-  // output and look for the U-prefixed lines (unresolved).
-  async rebaseTo(workspacePath2, fromRef) {
+  // We pre-check the WC and refuse with the typed WorkspaceDirtyError.
+  // `sl rebase` exits 0 on success (also when there is nothing to
+  // rebase) and 1 on unresolved conflicts. Conflict surface via
+  // `sl resolve --list --tool=internal:dumpjson` is brittle across
+  // versions, so on failure we read the textual `sl resolve --list`
+  // and keep the U-prefixed (unresolved) lines. A failure with no
+  // unresolved files (bad ref, unresolvable trunk()) is rethrown, as
+  // the git impl does.
+  async rebaseTo(workspacePath2, fromRef, previousParentRef) {
     if (!existsSync5(workspacePath2)) {
       throw new Error(`vcs sl: workspace path missing: ${workspacePath2}`);
     }
@@ -3685,25 +3914,41 @@ var slBackend = {
     if (dirtyFiles.length > 0) {
       throw new WorkspaceDirtyError(workspacePath2, dirtyFiles);
     }
-    await run(
-      "sl",
-      ["--config", "ui.username=mu <mu@local>", "rebase", "-d", target],
-      workspacePath2
-    ).catch(() => {
-    });
-    const conflicts = await listSlUnresolved(workspacePath2);
-    if (conflicts.length > 0) {
+    const headBefore = await slCommitId(workspacePath2);
+    try {
+      await run(
+        "sl",
+        ["--config", "ui.username=mu <mu@local>", "rebase", "-d", target],
+        workspacePath2
+      );
+    } catch (err) {
+      const conflicts = await listSlUnresolved(workspacePath2);
       await run("sl", ["rebase", "--abort"], workspacePath2).catch(() => {
       });
-      throw new WorkspaceConflictError(workspacePath2, target, conflicts);
+      if (conflicts.length > 0) {
+        throw new WorkspaceConflictError(workspacePath2, target, conflicts);
+      }
+      throw err;
     }
-    const replayedRaw = await run(
+    const targetNode = await run(
       "sl",
-      ["log", "-r", `${target}::. - ${target}`, "--template", "{desc|firstline}\\n"],
+      ["log", "-r", `last(${target})`, "--template", "{node}"],
       workspacePath2
     ).catch(() => "");
+    const keepPrevious = previousParentRef !== void 0 && targetNode.length > 0 && await run(
+      "sl",
+      ["log", "-r", `${previousParentRef} & ${targetNode}:: & ::.`, "--template", "{node}"],
+      workspacePath2
+    ).catch(() => "") !== "";
+    const parentRef = keepPrevious ? previousParentRef : targetNode;
+    const moved = await slCommitId(workspacePath2) !== headBefore;
+    const replayedRaw = moved ? await run(
+      "sl",
+      ["log", "-r", `${target}::. - ${target}`, "--template", "{desc|firstline}\\n"],
+      workspacePath2
+    ).catch(() => "") : "";
     const replayed = replayedRaw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
-    return { fromRef: target, replayed, conflicts: [] };
+    return parentRef.length > 0 ? { fromRef: target, parentRef, replayed, conflicts: [] } : { fromRef: target, replayed, conflicts: [] };
   },
   // List sl commits in (baseRef..., minus baseRef itself), oldest-
   // first. Same NUL-field / \x1e-record format as the jj impl;
@@ -3879,12 +4124,13 @@ async function freeWorkspace(db, agent, opts) {
     db,
     row.workstreamName,
     "workspace.free",
-    `workspace free ${agent} (backend=${row.backend}, path=${row.path}${result.committedRef ? `, committed=${result.committedRef.slice(0, 12)}` : ""})`
+    `workspace free ${agent} (backend=${row.backend}, path=${row.path}${result.committedRef ? `, committed=${result.committedRef.slice(0, 12)}` : ""}${result.branch ? `, branch=${result.branch}` : ""})`
   );
   return {
     removed: result.removed,
     rowDeleted: del.changes > 0,
-    ...result.committedRef !== void 0 ? { committedRef: result.committedRef } : {}
+    ...result.committedRef !== void 0 ? { committedRef: result.committedRef } : {},
+    ...result.branch !== void 0 ? { branch: result.branch } : {}
   };
 }
 async function isWorkspaceClean(row) {
@@ -4073,10 +4319,11 @@ function noteFromDb(row) {
     createdAt: row.created_at
   };
 }
-function lookupTaskAnyWorkstream(db, localId) {
+function lookupTaskAnyWorkstream(db, localId, preferWorkstream) {
   const row = db.prepare(
-    `SELECT ${SELECT_TASK_COLS} ${TASK_FROM_JOIN} WHERE t.local_id = ? ORDER BY ws.name LIMIT 1`
-  ).get(localId);
+    `SELECT ${SELECT_TASK_COLS} ${TASK_FROM_JOIN} WHERE t.local_id = ?
+        ORDER BY (ws.name = ?) DESC, ws.name LIMIT 1`
+  ).get(localId, preferWorkstream ?? null);
   return row ? rowFromDb3(row) : void 0;
 }
 function taskIdFor(db, localId, workstream) {
@@ -4101,6 +4348,16 @@ function getTask(db, localId, workstream) {
   ).get(wsId, localId);
   return row ? rowFromDb3(row) : void 0;
 }
+function getTaskOwner(db, localId, workstream) {
+  return db.prepare(
+    `SELECT a.name AS name, aws.name AS workstreamName
+         FROM tasks t
+         JOIN workstreams tws ON tws.id = t.workstream_id
+         JOIN agents a ON a.id = t.owner_id
+         JOIN workstreams aws ON aws.id = a.workstream_id
+        WHERE t.local_id = ? AND tws.name = ?`
+  ).get(localId, workstream);
+}
 function asList(v) {
   if (v === void 0) return void 0;
   return typeof v === "string" ? [v] : v;
@@ -4202,6 +4459,10 @@ function listNotes(db, taskLocalId, workstream, opts = {}) {
   const taskId = taskIdFor(db, taskLocalId, workstream);
   if (taskId === null) return [];
   let cutoff = opts.since;
+  if (cutoff !== void 0) {
+    const ms = Date.parse(cutoff);
+    if (!Number.isNaN(ms)) cutoff = new Date(ms).toISOString();
+  }
   if (cutoff === void 0 && opts.sinceClaim === true) {
     const at = lastClaimEventAt(db, workstream, taskLocalId);
     if (at !== null) cutoff = at;
@@ -4230,6 +4491,24 @@ function listTasksByOwner(db, workstream, owner, opts = {}) {
 }
 
 // src/tasks/id.ts
+var TaskTitleSlugEmptyError = class extends Error {
+  constructor(title) {
+    super(
+      `title yields empty slug: ${JSON.stringify(title)} (no ASCII letter or digit to derive an id from)`
+    );
+    this.title = title;
+  }
+  title;
+  name = "TaskTitleSlugEmptyError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "Pass the id explicitly as the positional",
+        command: 'mu task add <id> --title "..." --impact <n> --effort-days <n>'
+      }
+    ];
+  }
+};
 var TASK_ID_RE = /^[a-z][a-z0-9_-]{0,63}$/;
 function isValidTaskId(id) {
   return TASK_ID_RE.test(id);
@@ -4242,15 +4521,14 @@ function slugifyTitle(title) {
 function slugifyTitleVerbose(title) {
   const stripped = title.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   if (stripped.length === 0) {
-    throw new Error(`title yields empty slug: ${JSON.stringify(title)}`);
+    throw new TaskTitleSlugEmptyError(title);
   }
   let trimmed;
   if (stripped.length <= SLUG_SOFT_CAP) {
     trimmed = stripped;
   } else {
-    const window = stripped.slice(0, SLUG_SOFT_CAP);
-    const lastSep = window.lastIndexOf("_");
-    trimmed = lastSep > 0 ? window.slice(0, lastSep) : window;
+    const lastSep = stripped.lastIndexOf("_", SLUG_SOFT_CAP);
+    trimmed = lastSep > 0 ? stripped.slice(0, lastSep) : stripped.slice(0, SLUG_SOFT_CAP);
   }
   const applyPrefix = (s) => /^[a-z]/.test(s) ? s.slice(0, SLUG_HARD_CAP) : `t_${s}`.slice(0, SLUG_HARD_CAP);
   const slug = applyPrefix(trimmed);
@@ -4293,8 +4571,7 @@ var TaskNotFoundError = class extends Error {
     const recipe = `mu sql "SELECT ws.name AS workstream, t.local_id, t.status, t.title FROM tasks t JOIN workstreams ws ON ws.id = t.workstream_id WHERE LOWER(t.local_id) LIKE '%${idLit}%' OR LOWER(t.title) LIKE '%${idLit}%'"`;
     return [
       { intent: "List tasks in workstream", command: "mu task list -w <workstream>" },
-      { intent: "Search by substring (id + title)", command: recipe },
-      { intent: "Find which workstream owns it", command: recipe }
+      { intent: "Search every workstream by substring (id + title)", command: recipe }
     ];
   }
 };
@@ -4309,7 +4586,7 @@ var TaskIdInvalidError = class extends Error {
     const sanitised = sanitiseTaskId(this.attempted);
     return [
       {
-        intent: "Use the auto-derived id (drop --id and pass --title)",
+        intent: "Use the auto-derived id (drop the <id> positional; --title derives it)",
         command: 'mu task add --title "..." --impact <n> --effort-days <n>'
       },
       {
@@ -4419,6 +4696,24 @@ var ClaimerNotRegisteredError = class extends Error {
     return steps;
   }
 };
+var TaskClaimStaleWorkspaceError = class extends Error {
+  constructor(staleness) {
+    super(
+      `${staleness.agentName} workspace is ${staleness.commitsBehindMain} commits behind main (\u2265${WORKSPACE_STALE_THRESHOLD} = stale); refresh before dispatch or rerun without --strict-staleness`
+    );
+    this.staleness = staleness;
+  }
+  staleness;
+  name = "TaskClaimStaleWorkspaceError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "Refresh first",
+        command: `mu workspace refresh ${this.staleness.agentName} -w ${this.staleness.workstreamName}`
+      }
+    ];
+  }
+};
 var CycleError = class extends Error {
   constructor(from, to) {
     super(`adding edge ${from} -> ${to} would create a cycle`);
@@ -4445,6 +4740,38 @@ var CycleError = class extends Error {
     ];
   }
 };
+var ReaperDetectedDuringWaitError = class extends Error {
+  constructor(taskId, previousOwner, workstream) {
+    const ownerBit = previousOwner !== null ? `owner=${previousOwner}` : "owner=<unknown>";
+    super(
+      `task ${taskId} was IN_PROGRESS ${ownerBit} until just now; reaper detected dead pane and flipped to OPEN. wait abandoned. Re-dispatch a worker and retry.`
+    );
+    this.taskId = taskId;
+    this.previousOwner = previousOwner;
+    this.workstream = workstream;
+  }
+  taskId;
+  previousOwner;
+  workstream;
+  name = "ReaperDetectedDuringWaitError";
+  errorNextSteps() {
+    const ws = this.workstream;
+    return [
+      {
+        intent: "Inspect the task's current state",
+        command: `mu task show ${this.taskId} -w ${ws}`
+      },
+      {
+        intent: "List live agents in the workstream (post-reap)",
+        command: `mu agent list -w ${ws}`
+      },
+      {
+        intent: "Re-dispatch a fresh worker, then re-run the wait",
+        command: `mu agent spawn <name> -w ${ws}  &&  mu task claim ${this.taskId} --for <name> -w ${ws}`
+      }
+    ];
+  }
+};
 function stallWaitHint(owner, ws, runs) {
   if (runs === void 0 || runs < 1) return [];
   return [
@@ -4455,7 +4782,7 @@ function stallWaitHint(owner, ws, runs) {
   ];
 }
 var StallDetectedDuringWaitError = class extends Error {
-  constructor(taskName, owner, workstream, ageSecs, ownerExpectsCtl = false, ownerRuns) {
+  constructor(taskName, owner, workstream, ageSecs, ownerExpectsCtl = false, ownerRuns, ownerWorkstream = workstream) {
     const ownerBit = owner !== null ? owner : "<unknown>";
     super(
       `task ${taskName} owned by ${ownerBit} has been needs_input for ${ageSecs}s; exiting per --on-stall exit. Read the pane to see which it is \u2014 finished without closing, waiting on an answer, or sitting at a prompt.`
@@ -4466,6 +4793,7 @@ var StallDetectedDuringWaitError = class extends Error {
     this.ageSecs = ageSecs;
     this.ownerExpectsCtl = ownerExpectsCtl;
     this.ownerRuns = ownerRuns;
+    this.ownerWorkstream = ownerWorkstream;
   }
   taskName;
   owner;
@@ -4473,6 +4801,7 @@ var StallDetectedDuringWaitError = class extends Error {
   ageSecs;
   ownerExpectsCtl;
   ownerRuns;
+  ownerWorkstream;
   name = "StallDetectedDuringWaitError";
   /**
    * Diagnose before acting. `mu agent read` comes FIRST because the
@@ -4485,21 +4814,22 @@ var StallDetectedDuringWaitError = class extends Error {
    */
   errorNextSteps() {
     const ws = this.workstream;
+    const ownerWs = this.ownerWorkstream;
     const ownerBit = this.owner !== null ? this.owner : "<owner>";
     return [
-      ...stallWaitHint(ownerBit, ws, this.ownerRuns),
+      ...stallWaitHint(ownerBit, ownerWs, this.ownerRuns),
       {
         intent: "Read the worker's pane to see what it is waiting on",
-        command: `mu agent read ${ownerBit} -w ${ws} --lines 60`
+        command: `mu agent read ${ownerBit} -w ${ownerWs} --lines 60`
       },
       {
         intent: "Answer a question, or poke a worker that stalled mid-step",
-        command: `mu agent send ${ownerBit} '<answer-or-retry-instruction>' -w ${ws}`
+        command: `mu agent send ${ownerBit} '<answer-or-retry-instruction>' -w ${ownerWs}`
       },
       ...this.ownerExpectsCtl ? [
         {
           intent: "Stuck mid-turn? Stop it through the control socket before kick or close",
-          command: `mu agent abort ${ownerBit} -w ${ws}`
+          command: `mu agent abort ${ownerBit} -w ${ownerWs}`
         }
       ] : [],
       {
@@ -4531,12 +4861,12 @@ var CrossWorkstreamEdgeError = class extends Error {
   errorNextSteps() {
     return [
       {
-        intent: "Move the blocker into the dependent's workstream",
-        command: `mu sql "UPDATE tasks SET workstream_id=(SELECT id FROM workstreams WHERE name='${this.dependentWorkstream}') WHERE local_id='${this.blocker}' AND workstream_id=(SELECT id FROM workstreams WHERE name='${this.blockerWorkstream}')"`
+        intent: "Duplicate the blocker into the dependent's workstream",
+        command: `mu task add <new-id> -w ${this.dependentWorkstream} --title "<copy of ${this.blocker}>" --impact <n> --effort-days <n>`
       },
       {
-        intent: "Or duplicate the blocker (typed verb deferred)",
-        command: `mu task add <new-id> -w ${this.dependentWorkstream} --title "<copy of ${this.blocker}>" --impact <n> --effort-days <n>`
+        intent: "Or wait on the blocker across workstreams instead of an edge",
+        command: `mu task wait ${this.blockerWorkstream}/${this.blocker}`
       }
     ];
   }
@@ -4729,7 +5059,7 @@ function addBlockEdgeImpl(db, workstream, blocked, blocker) {
   }
   const blockedRow = getTask(db, blocked, workstream);
   if (!blockedRow) throw new TaskNotFoundError(blocked);
-  const blockerRow = lookupTaskAnyWorkstream(db, blocker);
+  const blockerRow = lookupTaskAnyWorkstream(db, blocker, blockedRow.workstreamName);
   if (!blockerRow) throw new TaskNotFoundError(blocker);
   if (blockedRow.workstreamName !== blockerRow.workstreamName) {
     throw new CrossWorkstreamEdgeError(
@@ -4755,7 +5085,7 @@ function addBlockEdgeImpl(db, workstream, blocked, blocker) {
       return true;
     }
     return false;
-  })();
+  }).immediate();
   return { added };
 }
 function removeBlockEdge(db, workstream, blocked, blocker) {
@@ -4780,7 +5110,7 @@ function removeBlockEdgeImpl(db, workstream, blocked, blocker) {
       return true;
     }
     return false;
-  })();
+  }).immediate();
   if (removed) {
   }
   return { removed };
@@ -4802,7 +5132,7 @@ function reparentTaskImpl(db, taskLocalId, blockers, scope) {
     if (blockerLocalId === taskLocalId) {
       throw new CycleError(blockerLocalId, taskLocalId);
     }
-    const blocker = lookupTaskAnyWorkstream(db, blockerLocalId);
+    const blocker = lookupTaskAnyWorkstream(db, blockerLocalId, task.workstreamName);
     if (!blocker) throw new TaskNotFoundError(blockerLocalId);
     if (blocker.workstreamName !== task.workstreamName) {
       throw new CrossWorkstreamEdgeError(
@@ -4836,7 +5166,7 @@ function reparentTaskImpl(db, taskLocalId, blockers, scope) {
     }
     touchTask(db, taskSurrogateId, now);
     return { removedEdges: removed.changes, addedEdges: blockerIds.length };
-  })();
+  }).immediate();
 }
 
 // src/workstream.ts
@@ -4862,6 +5192,27 @@ async function sessionAlive(session) {
 function isScratchWorkstream(name) {
   return RESERVED_WORKSTREAM_NAMES.has(name);
 }
+var MU_PLACEHOLDER_WINDOW = "_mu";
+async function ensureWorkstreamSession(session) {
+  const mux = await activeMux();
+  if (!await mux.sessionExists(session)) {
+    await mux.newSession(session, { detached: true, windowName: MU_PLACEHOLDER_WINDOW });
+    return { created: true, muWindowRepaired: false };
+  }
+  const windows = await mux.listWindows(session).catch(() => []);
+  if (windows.some((w) => w.name === MU_PLACEHOLDER_WINDOW)) {
+    return { created: false, muWindowRepaired: false };
+  }
+  await mux.newWindow({
+    session,
+    name: MU_PLACEHOLDER_WINDOW,
+    // A backend with no create-and-run form rejects a command and
+    // starts a shell anyway (see createOrReusePane in agents/spawn.ts).
+    command: mux.startAgentInPane === void 0 ? process.env.SHELL ?? "/bin/sh" : "",
+    detached: true
+  });
+  return { created: false, muWindowRepaired: true };
+}
 function isValidWorkstreamName(name) {
   if (!WORKSTREAM_NAME_RE.test(name)) return false;
   if (name.startsWith(RESERVED_WORKSTREAM_PREFIX)) return false;
@@ -4893,11 +5244,12 @@ var WorkstreamNameInvalidError = class extends Error {
   attempted;
   name = "WorkstreamNameInvalidError";
   errorNextSteps() {
-    const sanitized = this.attempted.toLowerCase().replace(/^mu-/, "").replace(/[.:]/g, "_").slice(0, 32);
+    const candidate = this.attempted.toLowerCase().replace(/^mu-/, "").replace(/[^a-z0-9_-]/g, "_").replace(/^[^a-z]+/, "").slice(0, 32);
+    const sanitized = isValidWorkstreamName(candidate) ? candidate : "<name>";
     const isPrefixCase = this.attempted.toLowerCase().startsWith(RESERVED_WORKSTREAM_PREFIX);
     const intent = isPrefixCase ? "Retry without the 'mu-' prefix" : "Try a sanitized name (best guess)";
     return [
-      { intent, command: `mu workstream init ${sanitized || "<name>"}` },
+      { intent, command: `mu workstream init ${sanitized}` },
       { intent: "List existing workstreams", command: "mu workstream list" }
     ];
   }
@@ -4905,6 +5257,25 @@ var WorkstreamNameInvalidError = class extends Error {
 function assertValidWorkstreamName(name) {
   if (!isValidWorkstreamName(name)) throw new WorkstreamNameInvalidError(name);
 }
+var WorkstreamNameReservedError = class extends Error {
+  constructor(attempted) {
+    super(
+      `workstream name ${JSON.stringify(attempted)} is reserved: it is the off-the-cuff bucket and auto-creates on first spawn. Don't 'init' it.`
+    );
+    this.attempted = attempted;
+  }
+  attempted;
+  name = "WorkstreamNameReservedError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "Just spawn into it (auto-creates)",
+        command: `mu agent spawn <name> -w ${this.attempted}`
+      },
+      { intent: "Use a durable workstream instead", command: "mu workstream init <name>" }
+    ];
+  }
+};
 function ensureWorkstream(db, name) {
   assertValidWorkstreamName(name);
   return withOpContext(
@@ -5132,7 +5503,7 @@ function addTaskImpl(db, opts) {
     const row = getTask(db, opts.localId, opts.workstream);
     if (!row) throw new Error(`addTask: row missing after insert: ${opts.localId}`);
     return row;
-  })();
+  }).immediate();
 }
 function addNote(db, taskLocalId, content, opts) {
   return withOpContext(
@@ -5153,7 +5524,7 @@ function insertNote(db, taskLocalId, content, opts) {
     const r = db.prepare("INSERT INTO task_notes (task_id, author, content, created_at) VALUES (?, ?, ?, ?)").run(taskId, opts.author ?? null, content, now);
     touchTask(db, taskId, now);
     return r;
-  })();
+  }).immediate();
   return {
     author: opts.author ?? null,
     content,
@@ -5171,11 +5542,25 @@ function deleteTaskImpl(db, localId, workstream, opts) {
   const dryRun = opts.dryRun === true;
   const before = getTask(db, localId, workstream);
   if (!before) {
-    return { deleted: false, deletedEdges: 0, deletedNotes: 0, dryRun, present: false };
+    return {
+      deleted: false,
+      deletedEdges: 0,
+      deletedNotes: 0,
+      dryRun,
+      present: false,
+      group: null
+    };
   }
   const taskId = taskIdFor(db, localId, before.workstreamName);
   if (taskId === null) {
-    return { deleted: false, deletedEdges: 0, deletedNotes: 0, dryRun, present: false };
+    return {
+      deleted: false,
+      deletedEdges: 0,
+      deletedNotes: 0,
+      dryRun,
+      present: false,
+      group: null
+    };
   }
   const edgesBefore = db.prepare("SELECT COUNT(*) AS n FROM task_edges WHERE from_task_id = ? OR to_task_id = ?").get(taskId, taskId).n;
   const notesBefore = db.prepare("SELECT COUNT(*) AS n FROM task_notes WHERE task_id = ?").get(taskId).n;
@@ -5185,7 +5570,8 @@ function deleteTaskImpl(db, localId, workstream, opts) {
       deletedEdges: edgesBefore,
       deletedNotes: notesBefore,
       dryRun: true,
-      present: true
+      present: true,
+      group: null
     };
   }
   const result = db.prepare("DELETE FROM tasks WHERE id = ?").run(taskId);
@@ -5195,7 +5581,9 @@ function deleteTaskImpl(db, localId, workstream, opts) {
     deletedEdges: edgesBefore,
     deletedNotes: notesBefore,
     dryRun: false,
-    present: true
+    present: true,
+    // deleteTask opened a fresh group around this call.
+    group: deleted ? currentOpContext(db).groupId : null
   };
 }
 function updateTask(db, localId, opts, scope) {
@@ -5286,8 +5674,8 @@ function closeTask(db, localId, opts) {
   );
 }
 function closeTaskImpl(db, localId, opts) {
-  const as = opts.as ?? "done";
   const before = getTask(db, localId, opts.workstream);
+  const as = opts.as ?? (before?.status === "CLOSED" ? before.substate : "done");
   if (opts.ifReady && before) {
     const edges = getTaskEdgesWithStatus(db, localId, before.workstreamName);
     const blocking = edges.blockers.filter((e) => e.status !== "CLOSED").map((e) => e.name).sort();
@@ -5314,9 +5702,11 @@ function closeTaskImpl(db, localId, opts) {
     if (!r.changed || !before) return { ...r, unblocked: [] };
     recordReasonNote(db, localId, before.workstreamName, as, opts.why, opts.author);
     recordEvidenceNote(db, localId, before.workstreamName, "CLOSE", opts);
-    const unblocked = track ? readyDependents(db, localId, before.workstreamName).filter((n) => !readyBefore.includes(n)) : [];
+    const unblocked = track ? readyDependents(db, localId, before.workstreamName).filter(
+      (n) => !readyBefore.includes(n)
+    ) : [];
     return { ...r, unblocked };
-  })();
+  }).immediate();
 }
 function readyDependents(db, localId, workstream) {
   const id = taskIdFor(db, localId, workstream);
@@ -5382,7 +5772,7 @@ function parkTask(db, localId, opts) {
         recordEvidenceNote(db, localId, before.workstreamName, "PARK", opts);
       }
       return r;
-    })()
+    }).immediate()
   );
 }
 function acceptTask(db, localId, opts) {
@@ -5404,7 +5794,7 @@ function acceptTask(db, localId, opts) {
       const r = setTaskStatus(db, localId, "OPEN", { workstream: opts.workstream });
       recordEvidenceNote(db, localId, before.workstreamName, "ACCEPT", opts);
       return r;
-    })()
+    }).immediate()
   );
 }
 function unparkTask(db, localId, opts) {
@@ -5426,7 +5816,7 @@ function unparkTask(db, localId, opts) {
       const r = setTaskStatus(db, localId, "OPEN", { workstream: opts.workstream });
       recordEvidenceNote(db, localId, before.workstreamName, "UNPARK", opts);
       return r;
-    })()
+    }).immediate()
   );
 }
 
@@ -5533,7 +5923,7 @@ async function claimTaskImpl(db, localId, opts) {
         previousStatus: before.status,
         status: after.status
       };
-    })()
+    }).immediate()
   );
 }
 function assertNotParked(task, opts) {
@@ -5596,7 +5986,7 @@ async function claimSelf(db, localId, opts) {
         previousStatus: before.status,
         status: after.status
       };
-    })()
+    }).immediate()
   );
 }
 
@@ -5664,11 +6054,11 @@ async function waitForTasks(db, input, opts) {
   const stuckLabel = /* @__PURE__ */ new Map();
   const ctlOwners = /* @__PURE__ */ new Set();
   const ownerRuns = /* @__PURE__ */ new Map();
-  const stuckAgeMs = async (status, owner, workstreamName) => {
-    if (stuckAfterMs <= 0 || status !== "IN_PROGRESS" || owner === null || opts.readOwnerState === void 0)
+  const stuckAgeMs = async (status, owner) => {
+    if (stuckAfterMs <= 0 || status !== "IN_PROGRESS" || owner === void 0 || opts.readOwnerState === void 0)
       return null;
-    const reading = await opts.readOwnerState({ name: owner, workstreamName });
-    const ownerKey = `${workstreamName}/${owner}`;
+    const reading = await opts.readOwnerState(owner);
+    const ownerKey = `${owner.workstreamName}/${owner.name}`;
     if (reading?.ctl !== void 0) ctlOwners.add(ownerKey);
     if (reading?.runs !== void 0) ownerRuns.set(ownerKey, reading.runs);
     else ownerRuns.delete(ownerKey);
@@ -5693,21 +6083,23 @@ async function waitForTasks(db, input, opts) {
       const row = getTask(db, ref.name, ref.workstreamName);
       const status = row?.status ?? "OPEN";
       const substate = row?.substate ?? DEFAULT_SUBSTATE[status];
-      const owner = row?.ownerName ?? null;
-      const ageMs = await stuckAgeMs(status, owner, ref.workstreamName);
+      const ownerRef = row === void 0 ? void 0 : getTaskOwner(db, ref.name, ref.workstreamName);
+      const owner = ownerRef?.name ?? row?.ownerName ?? null;
+      const ownerWs = ownerRef?.workstreamName ?? ref.workstreamName;
+      const ageMs = await stuckAgeMs(status, ownerRef);
       const stuck = ageMs !== null;
       const key = refKey(ref);
       if (ageMs !== null && !stuckWarned.has(key)) {
         stuckWarned.add(key);
         const ageSecs = Math.round(ageMs / 1e3);
         const ownerBit = owner ?? "<none>";
-        const runs = ownerRuns.get(`${ref.workstreamName}/${ownerBit}`);
-        const stateBit = stuckLabel.get(`${ref.workstreamName}/${ownerBit}`) ?? "needs_input";
-        const waitLine = stallWaitHint(ownerBit, ref.workstreamName, runs).map((s) => `  ${s.command}
+        const runs = ownerRuns.get(`${ownerWs}/${ownerBit}`);
+        const stateBit = stuckLabel.get(`${ownerWs}/${ownerBit}`) ?? "needs_input";
+        const waitLine = stallWaitHint(ownerBit, ownerWs, runs).map((s) => `  ${s.command}
 `).join("");
         currentStuckWarn(
           `\x1B[33mmu task wait: ${key} needs attention \u2014 owner=${ownerBit} has been in ${stateBit} for ${formatStallAge(ageMs)}. It may have finished without closing, be waiting on an answer, or be sitting at a prompt.\x1B[0m
-` + waitLine + `  mu agent read ${ownerBit} -w ${ref.workstreamName} --lines 60
+` + waitLine + `  mu agent read ${ownerBit} -w ${ownerWs} --lines 60
 `
         );
         emitEvent(
@@ -5723,8 +6115,9 @@ async function waitForTasks(db, input, opts) {
             owner,
             ref.workstreamName,
             ageSecs,
-            ctlOwners.has(`${ref.workstreamName}/${owner ?? ""}`),
-            runs
+            ctlOwners.has(`${ownerWs}/${owner ?? ""}`),
+            runs,
+            ownerWs
           );
         }
       }
@@ -5734,7 +6127,7 @@ async function waitForTasks(db, input, opts) {
         status,
         substate,
         owner,
-        reachedTarget: status === target,
+        reachedTarget: row !== void 0 && status === target,
         stuck
       });
     }
@@ -5810,7 +6203,7 @@ async function abortAgent(db, name, opts) {
 }
 async function interruptAgent(db, name, text, opts) {
   const r = await interruptAgentImpl(db, name, text, opts);
-  recordSend(db, { name, workstreamName: opts.workstream }, "interrupt", text.length, {
+  recordSend(db, { name, workstreamName: opts.workstream }, "interrupt", Buffer.byteLength(text), {
     transport: "ctl",
     wasBusy: r.wasBusy
   });
@@ -5866,11 +6259,7 @@ async function adoptAgent(db, opts) {
   const panesInSession = await mux.listPanesInSession(expectedSession);
   const matchingPane = panesInSession.find((p) => p.paneId === opts.paneId);
   if (!matchingPane) {
-    throw new AgentNotInWorkstreamError(
-      `pane ${opts.paneId}`,
-      opts.workstream,
-      "a different tmux session"
-    );
+    throw new PaneNotInSessionError(opts.paneId, opts.workstream, expectedSession);
   }
   const previousTitle = matchingPane.title.length > 0 ? matchingPane.title : null;
   const candidate = opts.name ?? (previousTitle !== null ? parseAgentNameFromTitle(previousTitle) : "");
@@ -6128,19 +6517,26 @@ function insertAgent(db, input) {
   ensureWorkstream(db, input.workstream);
   const workstreamId = resolveWorkstreamId(db, input.workstream);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.prepare(
-    `INSERT INTO agents (name, workstream_id, cli, pane_id, status, role, tab, created_at, updated_at)
-     VALUES (@name, @workstreamId, COALESCE(@cli, 'pi'), @paneId, 'spawning',
-             COALESCE(@role, 'full-access'), @tab, @now, @now)`
-  ).run({
-    name: input.name,
-    workstreamId,
-    cli: input.cli ?? null,
-    paneId: input.paneId,
-    role: input.role ?? null,
-    tab: input.tab ?? null,
-    now
-  });
+  try {
+    db.prepare(
+      `INSERT INTO agents (name, workstream_id, cli, pane_id, status, role, tab, created_at, updated_at)
+       VALUES (@name, @workstreamId, COALESCE(@cli, 'pi'), @paneId, 'spawning',
+               COALESCE(@role, 'full-access'), @tab, @now, @now)`
+    ).run({
+      name: input.name,
+      workstreamId,
+      cli: input.cli ?? null,
+      paneId: input.paneId,
+      role: input.role ?? null,
+      tab: input.tab ?? null,
+      now
+    });
+  } catch (err) {
+    if (err.code === "SQLITE_CONSTRAINT_UNIQUE") {
+      throw new AgentExistsError(input.name);
+    }
+    throw err;
+  }
   const row = getAgent(db, input.name, input.workstream);
   if (!row) throw new Error(`agents.insertAgent: row not found after insert: ${input.name}`);
   return row;
@@ -6230,7 +6626,7 @@ function deleteAgentRow(db, name, workstream) {
         );
       }
       return true;
-    })()
+    }).immediate()
   );
 }
 var AGENT_NAME_RE = /^[a-z][a-z0-9_-]{0,31}$/;
@@ -6248,7 +6644,7 @@ async function sendToAgent(db, name, text, opts) {
     db,
     agent,
     opts.fresh ? "fresh" : opts.mode === "steer" ? "steer" : "plain",
-    text.length,
+    Buffer.byteLength(text),
     {
       transport: sent.transport,
       command: sent.command,
@@ -6612,7 +7008,6 @@ async function spawnAgent(db, opts) {
   const workspacePathStr = opts.workspace ? await prestageWorkspace(db, opts, cli) : void 0;
   const ctlSocket = ctlSocketPath(opts.workstream, opts.name, dirname6(db.name));
   mkdirSync2(dirname6(ctlSocket), { recursive: true, mode: 448 });
-  rmSync4(ctlSocket, { force: true });
   const paneEnv = {
     MU_MANAGED_AGENT: "1",
     MU_AGENT_NAME: opts.name,
@@ -6622,12 +7017,18 @@ async function spawnAgent(db, opts) {
   const hasWorkspace = workspacePathStr !== void 0;
   let paneId;
   let agent;
+  let ownsRow = hasWorkspace;
   const wantsCtl = opts.ctl !== false && speaksMuCtl(cli, command) && defaultSpawnCtlMs() !== 0;
   let ctl;
   try {
     const created = await withSpawnLock(session, async () => {
+      if (!hasWorkspace && getAgent(db, opts.name, opts.workstream) !== void 0) {
+        throw new AgentExistsError(opts.name);
+      }
+      rmSync4(ctlSocket, { force: true });
       const pid = await createOrReusePane({
         session,
+        keepSessionAlive: isScratchWorkstream(opts.workstream),
         windowName,
         command,
         cwd: workspacePathStr ?? opts.cwd,
@@ -6638,6 +7039,7 @@ async function spawnAgent(db, opts) {
       await mux.setPaneTitle(pid, opts.name);
       await mux.enableMuPaneBordersForPane(pid);
       const row = finalizeAgentRow(db, { opts, cli, paneId: pid, hasWorkspace });
+      ownsRow = true;
       return { pid, row };
     });
     paneId = created.pid;
@@ -6657,7 +7059,7 @@ async function spawnAgent(db, opts) {
           throw new AgentDiedOnSpawnError(opts.name, pid, lastScrollback, command, when);
         };
         ctl = await awaitCtlHandshake(ctlSocket, check ? assertPaneAlive : void 0);
-        if (check) await checkSpawnHealth(pid, opts.name, command, when);
+        if (check) await checkSpawnHealth(pid, opts.name, command, when, ctl === "ok");
       } else {
         await awaitSpawnLiveness(paneId, opts.name, command);
       }
@@ -6665,7 +7067,7 @@ async function spawnAgent(db, opts) {
       await startAgent({ paneId, name: opts.name, cli, command, commandSource });
     }
   } catch (err) {
-    await rollbackSpawn(db, opts.name, paneId, hasWorkspace, opts.workstream);
+    await rollbackSpawn(db, opts.name, paneId, hasWorkspace, ownsRow, opts.workstream);
     if (hasWorkspace) attachOrphanCleanupHint(err, opts.name, opts.workstream);
     throw err;
   }
@@ -6724,7 +7126,7 @@ function finalizeAgentRow(db, args) {
   if (!row) throw new Error(`spawnAgent: agent vanished after workspace stage: ${opts.name}`);
   return row;
 }
-async function rollbackSpawn(db, name, paneId, hasWorkspace, workstream) {
+async function rollbackSpawn(db, name, paneId, hasWorkspace, ownsRow, workstream) {
   if (paneId !== void 0) {
     await activeMux().then((mux) => mux.killPane(paneId)).catch(() => {
     });
@@ -6733,7 +7135,7 @@ async function rollbackSpawn(db, name, paneId, hasWorkspace, workstream) {
     await freeWorkspace(db, name, { workstream }).catch(() => {
     });
   }
-  deleteAgent(db, name, workstream);
+  if (ownsRow) deleteAgent(db, name, workstream);
 }
 function attachOrphanCleanupHint(err, agent, workstream) {
   if (typeof err !== "object" || err === null) return;
@@ -6758,42 +7160,24 @@ function defaultSpawnLivenessMs() {
   if (Number.isNaN(parsed) || parsed < 0) return 1500;
   return parsed;
 }
-var STARTUP_ERROR_PATTERNS = [
+var AUTH_ERROR_PATTERNS = [
   /No API key found for [\w-]+/i,
   /Error: invalid API key/i,
   /Authentication failed/i,
   /401 Unauthorized/i,
-  /Could not authenticate/i,
-  // fb_agent_spawn_no_validation part B: post-spawn detection of the
-  // "binary not found at exec time" failure mode. The pre-flight check
-  // above catches the common typo BEFORE any side effect, but a few
-  // edge cases still slip through and only surface in the pane:
-  //   - `--command "..."` skips the pre-flight (operator opt-out).
-  //   - PATH inside the spawned shell differs from PATH in mu's
-  //     process (login shell rc files, /etc/paths.d, etc.).
-  //   - Race: binary on PATH at spawn time, gone 1.5s later.
-  //
-  // Anchored to lines that LOOK like a shell error rather than prose
-  // mentioning the marker (review_substrate_startup_err_patterns_too_broad):
-  // require the marker at end-of-line, optionally followed by a single
-  // `: <name>` token (the zsh form: `zsh: command not found: pi-meta`).
-  // This still trips the canonical cases —
-  //   `bash: pi-meta: command not found`
-  //   `zsh: command not found: pi-meta`
-  //   `sh: pi-meta: No such file or directory`
-  // — but rejects banner prose like
-  //   `I noticed earlier you saw 'command not found'`
-  //   `type \`mu\` — command not found? install with …`
-  // that previously triggered a full spawn rollback. The pre-flight
-  // PATH check remains the deterministic safety net for typo'd `--cli`.
-  /^(?:.*: )?(?:command not found|No such file or directory)(?::\s*\S+)?$/i
+  /Could not authenticate/i
 ];
+var EXEC_FAILURE_PATTERN = /^(?:.*: )?(?:command not found|No such file or directory)(?::\s*\S+)?$/i;
+function isExecFailureLine(line) {
+  return EXEC_FAILURE_PATTERN.test(line);
+}
 var STARTUP_ERROR_TAIL_LINES = 30;
-function detectSpawnStartupError(scrollback) {
+function detectSpawnStartupError(scrollback, cliStarted = false) {
+  const patterns = cliStarted ? AUTH_ERROR_PATTERNS : [...AUTH_ERROR_PATTERNS, EXEC_FAILURE_PATTERN];
   const lines = scrollback.split(/\r?\n/);
   const tail = lines.slice(Math.max(0, lines.length - STARTUP_ERROR_TAIL_LINES));
   for (const line of tail) {
-    for (const pattern of STARTUP_ERROR_PATTERNS) {
+    for (const pattern of patterns) {
       if (pattern.test(line)) return line;
     }
   }
@@ -6805,14 +7189,14 @@ async function awaitSpawnLiveness(paneId, agentName, command) {
   await sleep(ms);
   await checkSpawnHealth(paneId, agentName, command);
 }
-async function checkSpawnHealth(paneId, agentName, command, when) {
+async function checkSpawnHealth(paneId, agentName, command, when, cliStarted = false) {
   const mux = await activeMux();
   const scrollback = await mux.capturePane(paneId, { lines: 50 }).catch(() => void 0);
   if (!await mux.paneExists(paneId)) {
     throw new AgentDiedOnSpawnError(agentName, paneId, scrollback, command, when);
   }
   if (scrollback !== void 0) {
-    const matchedLine = detectSpawnStartupError(scrollback);
+    const matchedLine = detectSpawnStartupError(scrollback, cliStarted);
     if (matchedLine !== void 0) {
       throw new AgentSpawnStartupError(agentName, paneId, matchedLine, scrollback, when);
     }
@@ -6821,7 +7205,8 @@ async function checkSpawnHealth(paneId, agentName, command, when) {
 async function createOrReusePane(opts) {
   const mux = await activeMux();
   const command = mux.startAgentInPane === void 0 ? opts.command : "";
-  if (!await mux.sessionExists(opts.session)) {
+  if (opts.keepSessionAlive) await ensureWorkstreamSession(opts.session);
+  else if (!await mux.sessionExists(opts.session)) {
     return mux.newSessionWithPane(opts.session, {
       windowName: opts.windowName,
       command,
@@ -6833,12 +7218,17 @@ async function createOrReusePane(opts) {
   const matching = windows.find((w) => w.name === opts.windowName);
   if (matching) {
     return mux.splitWindow({
-      // tmux splits a WINDOW and accepts the `session:window` form;
+      // tmux splits a WINDOW: target it as `=<session>:<window_id>`.
+      // A bare `<session>:<name>` falls back to tmux's session prefix
+      // match, so if `mu-auth` vanishes between listWindows and here,
+      // `mu-auth:Backend` splits `mu-auth-refactor`'s Backend window.
+      // `=` makes the session exact and the stable window id (from
+      // the listing above) must live in that session, so a vanished
+      // session or window fails instead of landing elsewhere.
       // herdr splits a PANE and has no window-target form at all. Ask
       // the backend for a concrete pane in that window when it needs
-      // one — cheaper than a `target` union type for two backends, and
-      // the tmux string stays exactly as it was.
-      target: mux.startAgentInPane === void 0 ? `${opts.session}:${opts.windowName}` : await firstPaneInWindow(mux, opts.session, matching.id),
+      // one — cheaper than a `target` union type for two backends.
+      target: mux.startAgentInPane === void 0 ? `=${opts.session}:${matching.id}` : await firstPaneInWindow(mux, opts.session, matching.id),
       command,
       cwd: opts.cwd,
       env: opts.env
@@ -6968,6 +7358,32 @@ var AgentNotInWorkstreamError = class extends Error {
     ];
   }
 };
+var PaneNotInSessionError = class extends Error {
+  constructor(paneId, workstream, expectedSession) {
+    super(
+      `pane ${paneId} is not in session ${expectedSession}; adopt only takes panes from workstream ${workstream}'s own session`
+    );
+    this.paneId = paneId;
+    this.workstream = workstream;
+    this.expectedSession = expectedSession;
+  }
+  paneId;
+  workstream;
+  expectedSession;
+  name = "PaneNotInSessionError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "List the workstream's agents and orphan panes to pick one",
+        command: `mu agent list -w ${this.workstream}`
+      },
+      {
+        intent: "Or adopt it into the workstream whose session holds the pane",
+        command: `mu agent adopt ${this.paneId} -w <workstream>`
+      }
+    ];
+  }
+};
 var AgentDiedOnSpawnError = class extends Error {
   constructor(agentName, paneId, scrollback, command, when = `within ${defaultSpawnLivenessMs()}ms of spawn`) {
     const tail = scrollback?.trim();
@@ -7058,11 +7474,26 @@ ${scrollback.trim()}
   scrollback;
   name = "AgentSpawnStartupError";
   errorNextSteps() {
+    const inspect = {
+      intent: "Inspect the parked pane's scrollback for the full error",
+      command: `mu agent read ${this.agentName} -n 100`
+    };
+    const disable = {
+      intent: "Disable the startup-error scan if you actually wanted that prompt (CI / scripted recovery)",
+      command: "export MU_SPAWN_LIVENESS_MS=0"
+    };
+    if (isExecFailureLine(this.matchedLine.trim())) {
+      return [
+        inspect,
+        {
+          intent: "Check the spawned command resolves in the pane's shell (PATH, typo)",
+          command: `mu agent spawn ${this.agentName} --command "<full path to the CLI>"`
+        },
+        disable
+      ];
+    }
     return [
-      {
-        intent: "Inspect the parked pane's scrollback for the full error",
-        command: `mu agent read ${this.agentName} -n 100`
-      },
+      inspect,
       {
         // Most common today: the operator picked a model whose
         // provider has no credentials in this env. Default Anthropic
@@ -7074,10 +7505,7 @@ ${scrollback.trim()}
         intent: "Or set the missing API key env var for the provider you wanted, then re-spawn",
         command: "export ANTHROPIC_API_KEY=...   # or AWS_BEARER_TOKEN_BEDROCK, OPENAI_API_KEY, ..."
       },
-      {
-        intent: "Disable the startup-error scan if you actually wanted that prompt (CI / scripted recovery)",
-        command: "export MU_SPAWN_LIVENESS_MS=0"
-      }
+      disable
     ];
   }
 };
@@ -7984,13 +8412,17 @@ function applyDel(db, op) {
       const { taskKey: taskKey2 } = parseNoteKey(op.key);
       const taskId = taskRowId(db, taskKey2);
       if (taskId === null) return { changed: false, appliedFields: [], skipped: "absent" };
-      const src = db.prepare(
-        `SELECT payload FROM ops
-            WHERE entity = 'note' AND key = @key AND op = 'put'
-            ORDER BY hlc DESC LIMIT 1`
-      ).get({ key: op.key });
-      if (!src) return { changed: false, appliedFields: [], skipped: "absent" };
-      const entries = decodePayload(src.payload);
+      let entries = decodePayload(op.payload);
+      if (!entries.some(([f, v]) => f === "content" && v !== null)) {
+        const src = db.prepare(
+          `SELECT payload FROM ops
+              WHERE entity = 'note' AND key = @key AND op = 'put'
+                AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+              ORDER BY hlc DESC LIMIT 1`
+        ).get({ key: op.key });
+        if (!src) return { changed: false, appliedFields: [], skipped: "absent" };
+        entries = decodePayload(src.payload);
+      }
       const content = entries.find(([f]) => f === "content")?.[1] ?? "";
       const author = entries.find(([f]) => f === "author")?.[1] ?? null;
       const createdAt = entries.find(([f]) => f === "created_at")?.[1] ?? null;
@@ -8038,7 +8470,7 @@ function applyOp(db, op) {
       case "workstream":
         return applyWorkstreamPut(db, op);
       case "task":
-        return db.transaction(() => applyTaskPut(db, op))();
+        return db.transaction(() => applyTaskPut(db, op)).immediate();
       case "note":
         return applyNotePut(db, op);
       case "edge":
@@ -8145,7 +8577,7 @@ function installOpKeyFunctions(db) {
 function applyOps(db, ops) {
   const ordered = [...ops].sort((a, b) => compareHlc(a.hlc, b.hlc));
   const run2 = db.transaction(() => ordered.map((op) => applyOp(db, op)));
-  return run2();
+  return run2.immediate();
 }
 
 // src/dag.ts
@@ -8247,12 +8679,12 @@ import { delimiter as delimiter2, dirname as dirname10, join as join11, parse }
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/drift.ts
-import { mkdtempSync, rmSync as rmSync5 } from "fs";
+import { mkdtempSync, rmSync as rmSync6 } from "fs";
 import { tmpdir } from "os";
 import { join as join9 } from "path";
 
 // src/rebuild.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, statSync } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, rmSync as rmSync5, statSync } from "fs";
 import { dirname as dirname8 } from "path";
 var RebuildTargetExistsError = class extends Error {
   constructor(path) {
@@ -8320,7 +8752,7 @@ function rebuildInto(source, opts) {
   const identity = source.prepare(
     "SELECT machine_id, hostname, created_at, last_wall, last_counter FROM machine_identity WHERE id = 1"
   ).get();
-  if (!identity) throw new Error("source DB has no machine_identity row; not a v9 mu DB");
+  if (!identity) throw new Error("source DB has no machine_identity row; not a mu DB");
   const opRows = source.prepare(
     `SELECT hlc, machine_id, group_id, actor, intent, entity, key, op, payload, created_at
          FROM ops`
@@ -8332,6 +8764,9 @@ function rebuildInto(source, opts) {
     const row = source.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get();
     if (row.n > 0) machineLocalLost.push({ table, rows: row.n });
   }
+  if (opts.force === true) {
+    for (const suffix of ["", "-wal", "-shm"]) rmSync5(`${targetPath}${suffix}`, { force: true });
+  }
   const target = openDb({ path: targetPath });
   try {
     target.prepare(
@@ -8389,7 +8824,7 @@ function rebuildInto(source, opts) {
         }
       });
     });
-    replay();
+    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();
@@ -8602,7 +9037,7 @@ function checkDrift(db) {
       rebuilt.close();
     }
   } finally {
-    rmSync5(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+    rmSync6(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
   }
 }
 function formatDriftRecord(record) {
@@ -8659,6 +9094,16 @@ var DriftDetectedError = class extends Error {
 // src/fleet-hazards.ts
 import { existsSync as existsSync11, statfsSync } from "fs";
 import { resolve as resolve4, 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";
+};
 function isPathInside(child, parent) {
   const c = resolve4(child);
   const p = resolve4(parent);
@@ -8809,10 +9254,10 @@ function checkCaseCollisions(db) {
       "",
       "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 destroy the old one:",
+      "name, and tear down the old one:",
       "  mu db backup <file>",
       "  mu workstream init <new-name>",
-      "  mu workstream teardown <old-name>"
+      "  mu workstream teardown <old-name> --yes"
     ]
   };
 }
@@ -8833,7 +9278,7 @@ import {
   readFileSync,
   readlinkSync,
   realpathSync,
-  rmSync as rmSync6,
+  rmSync as rmSync7,
   symlinkSync,
   writeFileSync
 } from "fs";
@@ -8899,6 +9344,13 @@ function linkPi(opts) {
   if (!existsSync12(entry)) {
     throw new Error(`mu pi extension not built: ${entry} is missing (run npm run build)`);
   }
+  if (lstatOrUndefined(path)?.isSymbolicLink() === true) {
+    const current = resolve5(dirname9(path), readlinkSync(path));
+    if (existsSync12(current) && opts?.force !== true) {
+      throw new LinkConflictError(path, "foreign-symlink", current);
+    }
+    rmSync7(path);
+  }
   let replacedCopy = false;
   try {
     replacedCopy = !readFileSync(path, "utf8").includes(MU_SHIM_MARKER);
@@ -8921,7 +9373,7 @@ function linkSkill(opts) {
       throw new LinkConflictError(path, "foreign-symlink", current);
     }
     previous = current;
-    rmSync6(path);
+    rmSync7(path);
   }
   mkdirSync4(dirname9(path), { recursive: true });
   symlinkSync(target, path, "dir");
@@ -9122,7 +9574,7 @@ function loadDoctorSummary(db, snapshot2, agentStateSource = "murmur") {
       detail: `${cheapDrift.totalUnexplained} row(s) with no ops; run \`mu doctor --deep\``
     }
   );
-  return { checks, problemCount: countProblems(checks) };
+  return { checks, problemCount: countProblems(checks), agentStateSource };
 }
 function resolveExecutable(name) {
   for (const dir of (process.env.PATH ?? "").split(delimiter2).filter(Boolean)) {
@@ -9243,8 +9695,8 @@ function countProblems(checks) {
   for (const c of checks) if (c.status !== "ok") n++;
   return n;
 }
-function loadDoctorChecks(db, snapshot2) {
-  return loadDoctorSummary(db, snapshot2).checks;
+function loadDoctorChecks(db, snapshot2, agentStateSource = "murmur") {
+  return loadDoctorSummary(db, snapshot2, agentStateSource).checks;
 }
 function yankCommandForCheck(check) {
   switch (check.name) {
@@ -9319,10 +9771,13 @@ function remediationParagraph(check) {
       ];
     case "workspaces":
       return [
-        "An 'orphan workspace dir' is a per-agent VCS workspace under",
-        "the workstream that has no matching mu agent row. Run",
-        "`mu workspace orphans -w <ws>` to list them, then",
-        "`mu workspace free <agent>` to release each one."
+        "An 'orphan workspace dir' is a per-agent VCS workspace dir under",
+        "the workstream with no vcs_workspaces row, so `mu workspace free`",
+        "cannot remove it. mu never deletes it for you: it may hold the only",
+        "copy of uncommitted work. Run `mu workspace orphans -w <ws>` to list",
+        "them with a cleanup command, inspect each, then remove it by hand",
+        "(`git worktree remove --force <path>` from the project root for a",
+        "git checkout, else `rm -rf <path>`)."
       ];
     case "drift":
       return [
@@ -9363,18 +9818,20 @@ function remediationParagraph(check) {
       ];
     case "schema":
       return [
-        "Missing tables typically mean an older mu binary opened the",
-        "DB without running migrations. Rebuild mu (npm run build)",
-        "and re-open; openDb runs the migration block on every",
-        "process start."
+        "Missing tables mean something dropped them after mu created",
+        "them: every mu process runs CREATE TABLE IF NOT EXISTS for the",
+        "whole schema at open, so re-running any mu command restores an",
+        "empty table. If a table that held data is gone, back up the DB",
+        "and rebuild from the ops log: `mu rebuild <new-file>`."
       ];
     case "schema_version":
       return [
-        "Schema version mismatch means the DB was opened by a",
-        "different mu binary than the one running now. If `<` the",
-        "expected version, openDb should have migrated \u2014 check the",
-        "build. If `>` the expected, you may have a downgrade in",
-        "progress; restore from a snapshot rather than continuing."
+        "mu opens only a DB at exactly its own schema version: older",
+        "DBs are refused with SchemaTooOldError and newer ones with",
+        "SchemaTooNewError (exit 4), and there is no in-place migration.",
+        "A mismatch seen here means the row changed after open (an",
+        "external SQLite client). If `<` the expected version, migrate a",
+        "copy with scripts/migrate.ts; if `>`, use the newer mu binary."
       ];
     case "journal_mode":
       return [
@@ -9445,6 +9902,7 @@ var VERBS = {
   "task.open": "task open",
   "task.park": "task park",
   "task.unpark": "task unpark",
+  "task.accept": "task accept",
   "task.reject": "task reject",
   "task.defer": "task defer",
   "task.claim": "task claim",
@@ -9456,6 +9914,7 @@ var VERBS = {
   "workstream.init": "workstream init",
   "workstream.teardown": "workstream teardown",
   "workstream.destroy": "workstream teardown",
+  "sql.write": "sql write",
   "agent.spawn": "agent spawn",
   "agent.close": "agent close",
   "agent.adopt": "agent adopt",
@@ -9539,7 +9998,8 @@ function renderKnown(row, intent) {
       };
     }
     case "task.park":
-    case "task.unpark": {
+    case "task.unpark":
+    case "task.accept": {
       const detail = str(bag, "substate") === void 0 ? "" : `\u2192 ${pairText(bag, "OPEN")}`;
       return { verb: VERBS[intent], subject, detail };
     }
@@ -9575,6 +10035,19 @@ function renderKnown(row, intent) {
         subject,
         detail: key.local === void 0 ? "" : "(cascaded)"
       };
+    case "sql.write": {
+      if (deleted) return { verb: VERBS[intent], subject, detail: `${row.kind} deleted` };
+      const edge = key.to === void 0 ? "" : ` -> ${key.to}`;
+      const changed = changedFields(bag).map((f) => {
+        const v = bag[f];
+        return typeof v === "object" && v !== null ? f : `${f}=${oneLine(String(v), 40)}`;
+      }).join(" ");
+      return {
+        verb: VERBS[intent],
+        subject,
+        detail: `${row.kind}${edge} ${changed === "" ? "(touched)" : changed}`
+      };
+    }
     // Local intents: no trigger can see these, so `emitEvent` wrote the
     // payload as prose. It is already human-readable — show it as the
     // detail rather than inventing a second phrasing. The leading verb
@@ -9663,7 +10136,7 @@ function refuseUserSyncDirDuringTests(dir) {
 }
 function localMachineId(db) {
   const row = db.prepare("SELECT machine_id FROM machine_identity WHERE id = 1").get();
-  if (row === void 0) throw new Error("machine_identity row missing; not a v9 mu DB");
+  if (row === void 0) throw new Error("machine_identity row missing; not a mu DB");
   return row.machine_id;
 }
 function segmentPath(dir, machineId2) {
@@ -9875,14 +10348,17 @@ function segmentLineCount(path) {
 }
 function readSegmentTail(path) {
   if (!existsSync14(path)) return { count: 0, lastHlc: null, goodLines: [], defect: null };
-  const raw = readFileSync3(path, "utf8");
-  const lines = raw.split("\n").filter((l) => l.trim() !== "");
+  const lines = segmentLines(readFileSync3(path, "utf8"));
   let lastHlc = null;
   let count = 0;
   let defect = null;
   for (let index = 0; index < lines.length; index++) {
     const line = lines[index];
     if (line === void 0) break;
+    if (line.trim() === "") {
+      defect = { kind: "malformed-shape", line: index + 1, detail: "blank line" };
+      break;
+    }
     const decoded = decodeLine(line);
     if (!decoded.ok) {
       defect = { kind: decoded.kind, line: index + 1, detail: decoded.detail };
@@ -9893,6 +10369,11 @@ function readSegmentTail(path) {
   }
   return { count, lastHlc, goodLines: lines.slice(0, count), defect };
 }
+function segmentLines(raw) {
+  const lines = raw.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
 function writeManifest(path, machine, count, lastHlc) {
   const bytes = existsSync14(path) ? readFileSync3(path) : Buffer.alloc(0);
   const manifest = {
@@ -9946,28 +10427,32 @@ function discoverPeers(dir, selfMachineId) {
     } catch {
       continue;
     }
-    peers.push({ machineId: machineId2, path, conflictCopy });
+    peers.push({ machineId: machineId2, watermarkKey: conflictCopy ? stem : machineId2, path, conflictCopy });
   }
   return peers.sort((a, b) => a.path.localeCompare(b.path));
 }
-function getWatermark(db, machineId2) {
-  const row = db.prepare("SELECT last_applied_seq AS n FROM sync_peers WHERE machine_id = ?").get(machineId2);
+function peerWatermarkKey(peer) {
+  return peer.watermarkKey ?? peer.machineId;
+}
+function getWatermark(db, watermarkKey) {
+  const row = db.prepare("SELECT last_applied_seq AS n FROM sync_peers WHERE machine_id = ?").get(watermarkKey);
   return row?.n ?? 0;
 }
-function setWatermark(db, machineId2, value) {
+function setWatermark(db, watermarkKey, value) {
   db.prepare(
     `INSERT INTO sync_peers (machine_id, last_applied_seq, last_seen_at)
      VALUES (@machineId, @value, @seenAt)
      ON CONFLICT (machine_id) DO UPDATE
        SET last_applied_seq = @value, last_seen_at = @seenAt`
-  ).run({ machineId: machineId2, value, seenAt: (/* @__PURE__ */ new Date()).toISOString() });
+  ).run({ machineId: watermarkKey, value, seenAt: (/* @__PURE__ */ new Date()).toISOString() });
 }
-function resetWatermark(db, machineId2) {
-  setWatermark(db, machineId2, 0);
+function resetWatermark(db, watermarkKey) {
+  setWatermark(db, watermarkKey, 0);
 }
 function ingestSegment(db, peer) {
   const defects = [];
-  const start = getWatermark(db, peer.machineId);
+  const watermarkKey = peerWatermarkKey(peer);
+  const start = getWatermark(db, watermarkKey);
   if (!existsSync14(peer.path)) {
     return {
       machineId: peer.machineId,
@@ -9984,9 +10469,7 @@ function ingestSegment(db, peer) {
   if (!verified.ok) {
     defects.push({ kind: "manifest-mismatch", line: 0, detail: verified.reason });
   }
-  const raw = readFileSync3(peer.path, "utf8");
-  const lines = raw.split("\n");
-  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const lines = segmentLines(readFileSync3(peer.path, "utf8"));
   let applied = 0;
   let changed = 0;
   let watermark = start;
@@ -10001,14 +10484,14 @@ function ingestSegment(db, peer) {
   }
   const run2 = db.transaction(() => {
     for (let index = start; index < lines.length; index++) {
-      const raw2 = lines[index];
+      const raw = lines[index];
       const lineNo = index + 1;
-      if (raw2 === void 0 || raw2.trim() === "") {
+      if (raw === void 0 || raw.trim() === "") {
         defects.push({ kind: "malformed-shape", line: lineNo, detail: "blank line" });
         truncatedAt = lineNo;
         break;
       }
-      const decoded = decodeLine(raw2);
+      const decoded = decodeLine(raw);
       if (!decoded.ok) {
         defects.push({ kind: decoded.kind, line: lineNo, detail: decoded.detail });
         truncatedAt = lineNo;
@@ -10043,6 +10526,11 @@ function ingestSegment(db, peer) {
         truncatedAt = lineNo;
         break;
       }
+      if (isLegacyLogOnlyIntent(decoded.line.intent)) {
+        previousHlc = op.hlc;
+        watermark = lineNo;
+        continue;
+      }
       try {
         const result = applyIncomingOp(db, op);
         if (result.changed) changed += 1;
@@ -10063,13 +10551,13 @@ function ingestSegment(db, peer) {
       previousHlc = op.hlc;
       watermark = lineNo;
     }
-    setWatermark(db, peer.machineId, watermark);
+    setWatermark(db, watermarkKey, watermark);
   });
-  run2();
+  run2.immediate();
   return {
     machineId: peer.machineId,
     path: peer.path,
-    read: applied,
+    read: watermark - start,
     applied,
     changed,
     watermark,
@@ -10282,7 +10770,7 @@ async function loadWorkstreamSnapshotFast(db, workstream, opts = {}) {
 }
 async function loadWorkstreamSnapshotSlow(db, workstream, opts = {}, baseSnapshot) {
   const view = await listLiveAgents(db, { workstream });
-  let workspaces = listWorkspaces2(db, workstream);
+  let workspaces = await decorateWithStaleness(listWorkspaces2(db, workstream));
   if (opts.withDirty === true) workspaces = await decorateWithDirty(workspaces);
   const commits = await loadRecentCommits(opts.withRecentCommits);
   const slow = {
@@ -10315,12 +10803,8 @@ function mergeSnapshotFastSlow(fast, slow) {
 }
 async function loadWorkstreamSnapshot(db, workstream, opts = {}) {
   const fast = await loadWorkstreamSnapshotFast(db, workstream, opts);
-  const fastWithStaleness = {
-    ...fast,
-    workspaces: await decorateWithStaleness(fast.workspaces)
-  };
-  const slow = await loadWorkstreamSnapshotSlow(db, workstream, opts, fastWithStaleness);
-  return mergeSnapshotFastSlow(fastWithStaleness, slow);
+  const slow = await loadWorkstreamSnapshotSlow(db, workstream, opts, fast);
+  return mergeSnapshotFastSlow(fast, slow);
 }
 function emptyLiveAgentsView() {
   return {
@@ -10449,13 +10933,15 @@ function peerStatuses(db, dir) {
       lastSeenMs = null;
     }
     const total = segmentLineCount(peer.path);
-    const watermark = getWatermark(db, peer.machineId);
+    const watermarkKey = peerWatermarkKey(peer);
+    const watermark = getWatermark(db, watermarkKey);
     const ageMs = lastSeenMs === null ? null : Math.max(0, now - lastSeenMs);
     return {
       machineId: peer.machineId,
       short: peer.machineId.slice(0, PEER_SHORT_LEN),
       path: peer.path,
       conflictCopy: peer.conflictCopy,
+      watermarkKey,
       watermark,
       total,
       behind: Math.max(0, total - watermark),
@@ -10467,27 +10953,31 @@ function peerStatuses(db, dir) {
   return rows.sort((a, b) => (b.lastSeenMs ?? 0) - (a.lastSeenMs ?? 0));
 }
 function resolvePeerRef(peers, ref) {
-  const exact = peers.find((p) => p.machineId === ref);
-  if (exact !== void 0) return exact;
   const matches = peers.filter((p) => p.machineId.startsWith(ref));
-  const first = matches[0];
+  const exact = matches.filter((p) => p.machineId === ref);
+  const candidates = exact.length > 0 ? exact : matches;
+  const machines = [...new Set(candidates.map((p) => p.machineId))];
+  const first = candidates.find((p) => !p.conflictCopy) ?? candidates[0];
   if (first === void 0) {
     throw new SyncPeerNotFoundError(
       ref,
       peers.map((p) => p.short)
     );
   }
-  if (matches.length > 1) {
+  if (machines.length > 1) {
     throw new SyncPeerRefAmbiguousError(
       ref,
-      matches.map((p) => p.short)
+      machines.map((m) => m.slice(0, PEER_SHORT_LEN))
     );
   }
   return first;
 }
 function repairPeer(db, ref, dir) {
-  const peer = resolvePeerRef(peerStatuses(db, dir), ref);
-  resetWatermark(db, peer.machineId);
+  const peers = peerStatuses(db, dir);
+  const peer = resolvePeerRef(peers, ref);
+  for (const p of peers) {
+    if (p.machineId === peer.machineId) resetWatermark(db, peerWatermarkKey(p));
+  }
   return peer;
 }
 function syncEnabled() {
@@ -10503,7 +10993,15 @@ function describeDefects(peerShort, defects) {
   const detail = first === void 0 ? "unknown defect" : `${first.kind} at line ${first.line}`;
   const more = defects.length > 1 ? ` (+${defects.length - 1} more)` : "";
   const skipped = /* @__PURE__ */ new Set(["entity-not-synced", "duplicate-op"]);
-  const hint = defects.every((d) => skipped.has(d.kind)) ? " \u2014 skipped; the rest of the segment applied" : ` \u2014 re-read with \`mu sync --repair ${peerShort}\``;
+  const fileWide = /* @__PURE__ */ new Set(["manifest-mismatch"]);
+  let hint;
+  if (defects.every((d) => skipped.has(d.kind))) {
+    hint = " \u2014 skipped; the rest of the segment applied";
+  } else if (defects.every((d) => skipped.has(d.kind) || fileWide.has(d.kind))) {
+    hint = " \u2014 the file is shorter than its manifest; copy it from the peer again";
+  } else {
+    hint = ` \u2014 re-read with \`mu sync --repair ${peerShort}\``;
+  }
   return `peer ${peerShort}: ${detail}${more}${hint}`;
 }
 async function ambientIngest(db, opts) {
@@ -10597,7 +11095,7 @@ function ingestFromDb(db, path) {
         if (result.changed) changed += 1;
       }
     });
-    run2();
+    run2.immediate();
     changed += reprojectDeferredOps(db);
     return { path, read, changed, skippedLocal };
   } finally {
@@ -10680,7 +11178,7 @@ var ENTITY_RESTORE_ORDER = {
 function restoreRank(entity) {
   return ENTITY_RESTORE_ORDER[entity] ?? 3;
 }
-function priorFieldValue(db, entity, key, hlc, field) {
+function priorFieldValue(db, entity, key, hlc, field, machineId2) {
   const row = db.prepare(
     `SELECT json_extract(payload, '$.' || @field) AS value
          FROM ops
@@ -10688,15 +11186,16 @@ function priorFieldValue(db, entity, key, hlc, field) {
           AND key    = @key
           AND op     = 'put'
           AND hlc    < @hlc
+          AND (@machineId IS NULL OR machine_id = @machineId)
           AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
           AND json_type(payload, '$.' || @field) IS NOT NULL
         ORDER BY hlc DESC
         LIMIT 1`
-  ).get({ entity, key, hlc, field });
+  ).get({ entity, key, hlc, field, machineId: machineId2 ?? null });
   if (row === void 0) return { found: false };
   return { found: true, value: row.value };
 }
-function laterWriters(db, entity, key, hlc, field, excludeGroup) {
+function laterWriters(db, entity, key, hlc, field, excludeGroup, machineId2) {
   return db.prepare(
     `SELECT DISTINCT group_id AS groupId, intent
          FROM ops
@@ -10705,9 +11204,10 @@ function laterWriters(db, entity, key, hlc, field, excludeGroup) {
           AND op       = 'put'
           AND hlc      > @hlc
           AND group_id <> @excludeGroup
+          AND (@machineId IS NULL OR machine_id = @machineId)
           AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
           AND json_type(payload, '$.' || @field) IS NOT NULL`
-  ).all({ entity, key, hlc, field, excludeGroup });
+  ).all({ entity, key, hlc, field, excludeGroup, machineId: machineId2 ?? null });
 }
 function laterRowWriters(db, entity, key, hlc, excludeGroup) {
   return db.prepare(
@@ -10721,6 +11221,15 @@ function laterRowWriters(db, entity, key, hlc, excludeGroup) {
           AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}`
   ).all({ entity, key, hlc, excludeGroup });
 }
+function isDeletedByLaterGroup(db, entity, key, groupId) {
+  const row = db.prepare(
+    `SELECT op, group_id AS groupId FROM ops
+        WHERE entity = @entity AND key = @key
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+        ORDER BY hlc DESC LIMIT 1`
+  ).get({ entity, key });
+  return row?.op === "del" && row.groupId !== groupId;
+}
 function laterDeleters(db, entity, key, hlc, excludeGroup) {
   return db.prepare(
     `SELECT DISTINCT group_id AS groupId, intent
@@ -10741,6 +11250,7 @@ function listRecentGroups(db, limit = 10) {
               MAX(actor)                  AS actor
          FROM ops
         WHERE entity IN ('workstream','task','note','edge')
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
         GROUP BY group_id
         ORDER BY MAX(hlc) DESC
         LIMIT @limit`
@@ -10775,24 +11285,36 @@ var CAPTURED_TABLE_FOR = {
   note: "task_notes",
   edge: "task_edges"
 };
-var NEVER_RESTORE = /* @__PURE__ */ new Set(["id", "local_id", "name", "workstream_id", "task_id", "owner_id"]);
+var NEVER_RESTORE = /* @__PURE__ */ new Set(["id", "local_id", "name", "workstream_id", "task_id"]);
+var OWNER_FIELD = "owner_id";
+var NEVER_RECONSTRUCT = /* @__PURE__ */ new Set([...NEVER_RESTORE, OWNER_FIELD]);
+var TOUCH_FIELD = "updated_at";
 function planUndo(db, groupId) {
   const rows = db.prepare(
-    `SELECT o.seq, o.hlc, o.group_id, o.intent, o.actor, o.entity, o.key, o.op, o.payload,
+    `SELECT o.seq, o.hlc, o.group_id, o.machine_id, o.intent, o.actor, o.entity, o.key, o.op, o.payload,
               (SELECT COUNT(*) FROM ops p
-                WHERE p.entity = o.entity AND p.key = o.key AND p.hlc < o.hlc) AS prior,
+                WHERE p.entity = o.entity AND p.key = o.key AND p.hlc < o.hlc
+                  AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}) AS prior,
               (SELECT p.op FROM ops p
                 WHERE p.entity = o.entity AND p.key = o.key AND p.hlc < o.hlc
+                  AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
                 ORDER BY p.hlc DESC LIMIT 1) AS priorKind
          FROM ops o
         WHERE o.group_id = @groupId
           AND o.entity IN ('workstream','task','note','edge')
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
         ORDER BY o.hlc`
   ).all({ groupId });
   if (rows.length === 0) throw new UndoGroupNotFoundError(groupId);
   const inverses = [];
   let skipped = 0;
   const seenLegacyNoteTasks = /* @__PURE__ */ new Set();
+  const restoredFields = /* @__PURE__ */ new Map();
+  let machine;
+  const localMachine = () => {
+    machine ??= localMachineId(db);
+    return machine;
+  };
   for (const row of rows) {
     if (row.op === "del") {
       let fields3 = reconstructRow(db, row.entity, row.key, row.hlc);
@@ -10834,6 +11356,10 @@ function planUndo(db, groupId) {
       continue;
     }
     if (row.prior === 0 || row.priorKind === "del") {
+      if (isDeletedByLaterGroup(db, row.entity, row.key, groupId)) {
+        skipped += 1;
+        continue;
+      }
       const later = [...laterRowWriters(db, row.entity, row.key, row.hlc, groupId)];
       inverses.push({
         entity: row.entity,
@@ -10848,14 +11374,26 @@ function planUndo(db, groupId) {
     const payload = JSON.parse(row.payload);
     const fields2 = {};
     const supersededBy = [];
+    const rowKey = `${row.entity}\0${row.key}`;
+    const restored = restoredFields.get(rowKey) ?? /* @__PURE__ */ new Set();
+    restoredFields.set(rowKey, restored);
     for (const field of Object.keys(payload)) {
-      if (NEVER_RESTORE.has(field)) continue;
-      const prior = priorFieldValue(db, row.entity, row.key, row.hlc, field);
+      if (NEVER_RESTORE.has(field) || restored.has(field)) continue;
+      restored.add(field);
+      let machineId2;
+      if (field === OWNER_FIELD) {
+        if (row.machine_id !== localMachine()) continue;
+        machineId2 = localMachine();
+      }
+      const prior = field === OWNER_FIELD ? priorOwner(db, row.key, row.hlc, localMachine()) : priorFieldValue(db, row.entity, row.key, row.hlc, field, machineId2);
       if (!prior.found) {
         continue;
       }
+      if (field === OWNER_FIELD && prior.value !== null && !agentExists(db, prior.value)) continue;
+      const writers = laterWriters(db, row.entity, row.key, row.hlc, field, groupId, machineId2);
+      if (field === TOUCH_FIELD && writers.length > 0) continue;
       fields2[field] = prior.value;
-      for (const writer of laterWriters(db, row.entity, row.key, row.hlc, field, groupId)) {
+      for (const writer of writers) {
         supersededBy.push({ field, groupId: writer.groupId, intent: writer.intent });
       }
     }
@@ -10890,6 +11428,27 @@ function planUndo(db, groupId) {
     skipped
   };
 }
+function priorOwner(db, key, hlc, machineId2) {
+  const local = priorFieldValue(db, "task", key, hlc, OWNER_FIELD, machineId2);
+  if (!local.found) return { found: true, value: null };
+  const tomb = db.prepare(
+    `SELECT 1 FROM ops d
+        WHERE d.entity = 'task' AND d.key = @key AND d.op = 'del' AND d.hlc < @hlc
+          AND d.hlc > (SELECT MAX(hlc) FROM ops
+                        WHERE entity = 'task' AND key = @key AND op = 'put'
+                          AND hlc < @hlc AND machine_id = @machineId
+                          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+                          AND json_type(payload, '$.owner_id') IS NOT NULL)
+          AND NOT EXISTS (SELECT 1 FROM ops p
+                           WHERE p.entity = 'task' AND p.key = @key AND p.op = 'put'
+                             AND p.hlc > d.hlc AND p.seq < d.seq)
+        LIMIT 1`
+  ).get({ key, hlc, machineId: machineId2 });
+  return tomb === void 0 ? local : { found: true, value: null };
+}
+function agentExists(db, id) {
+  return db.prepare("SELECT 1 FROM agents WHERE id = ?").get(id) !== void 0;
+}
 function groupWhen(db, groupId) {
   const row = db.prepare("SELECT MIN(created_at) AS when_ FROM ops WHERE group_id = ?").get(groupId);
   return row?.when_ ?? "";
@@ -10924,7 +11483,7 @@ function payloadFields(payload) {
   const fields2 = {};
   const parsed = JSON.parse(payload);
   for (const [field, value] of Object.entries(parsed)) {
-    if (NEVER_RESTORE.has(field)) continue;
+    if (NEVER_RECONSTRUCT.has(field)) continue;
     if (value === null || typeof value === "string" || typeof value === "number") {
       fields2[field] = value;
     }
@@ -10942,7 +11501,7 @@ function reconstructRow(db, entity, key, beforeHlc) {
   for (const put of puts) {
     const parsed = JSON.parse(put.payload);
     for (const [field, value] of Object.entries(parsed)) {
-      if (NEVER_RESTORE.has(field)) continue;
+      if (NEVER_RECONSTRUCT.has(field)) continue;
       if (value === null || typeof value === "string" || typeof value === "number") {
         fields2[field] = value;
       }
@@ -10973,8 +11532,8 @@ function undoGroup(db, groupId, opts = {}) {
       }
     );
   });
-  run2();
-  return { plan, undoGroupId, applied };
+  run2.immediate();
+  return { plan, undoGroupId: applied > 0 && undoGroupId !== "" ? undoGroupId : null, applied };
 }
 function applyInverse(db, inverse) {
   const table = CAPTURED_TABLE_FOR[inverse.entity];
@@ -11183,6 +11742,7 @@ export {
   AgentCtlUnreachableError,
   AgentDiedOnSpawnError,
   AgentExistsError,
+  AgentExtensionOutdatedError,
   AgentFreshNeedsCtlError,
   AgentNotFoundError,
   AgentNotInWorkstreamError,
@@ -11199,6 +11759,8 @@ export {
   DriftDetectedError,
   EXPECTED_TABLES,
   GLYPH,
+  GroupIdAmbiguousError,
+  HazardFailError,
   HlcOverflowError,
   HlcParseError,
   HomeDirAsProjectRootError,
@@ -11206,6 +11768,7 @@ export {
   KNOWN_INTENTS,
   KNOWN_VERBS,
   LinkConflictError,
+  LogKindReservedError,
   MACHINE_LOCAL_ENTITIES,
   MACHINE_LOCAL_TABLES,
   MU_SHIM_MARKER,
@@ -11222,11 +11785,15 @@ export {
   PEER_STALE_MS,
   PORTABLE_TABLES,
   PaneNotFoundError,
+  PaneNotInSessionError,
+  ReaperDetectedDuringWaitError,
   RebuildTargetExistsError,
   RebuildTargetIsSourceError,
   SEGMENT_FORMAT_VERSION,
   SYNCED_ENTITIES,
+  SchemaTooNewError,
   SchemaTooOldError,
+  StallDetectedDuringWaitError,
   SubstateReasonRequiredError,
   SyncPeerNotFoundError,
   SyncPeerRefAmbiguousError,
@@ -11236,23 +11803,31 @@ export {
   TASK_SUBSTATES,
   TASK_SUBSTATE_ROWS,
   TaskAlreadyOwnedError,
+  TaskClaimStaleWorkspaceError,
   TaskExistsError,
+  TaskIdInvalidError,
   TaskInTriageError,
   TaskNotFoundError,
   TaskNotInWorkstreamError,
   TaskParkStateError,
   TaskParkedError,
+  TaskTitleSlugEmptyError,
   TmuxError,
   UNKNOWN_REASON,
   UndoGroupNotFoundError,
   UndoSupersededError,
   WORKSPACE_STALE_THRESHOLD,
+  WorkspaceConflictError,
+  WorkspaceDirtyError,
   WorkspaceExistsError,
   WorkspaceNotFoundError,
   WorkspacePathNotEmptyError,
   WorkspacePreservedError,
+  WorkspaceVcsRequiredError,
   WorkstreamExistsError,
   WorkstreamNameInvalidError,
+  WorkstreamNameReservedError,
+  WorkstreamNotFoundError,
   abortAgent,
   acceptTask,
   activeMux,