@mu-crew/mu 4.0.0 → 4.1.0

package/dist/{chunk-S424D5EP.js → chunk-UCZPJX7K.js}

@@ -1999,7 +1999,7 @@ Matched line: ${line}${scroll}`,
   "agent.spawn_cwd_worktree": () => "--cwd conflicts with --worktree (the worktree is the cwd)",
   "agent.spawn_needs_worktree": (flag) => `--${flag} requires --worktree`,
   "agent.spawn_gate_flag": (flag) => `--${flag} cannot be used with a remote command gate (--host with a non-pi --command): it runs one command and reports its exit; wait on it`,
-  "agent.spawn_gate_worktree": () => "--worktree cannot be used with a remote command gate (--host with a non-pi --command): a gate runs in the profile's repo or --cwd",
+  "agent.spawn_gate_worktree": () => "--worktree cannot be used with a remote command gate (--host with a non-pi --command): a gate runs in --cwd, else the profile's default repo",
   "agent.spawn_attempt_task": () => "--attempt needs --task",
   "agent.spawn_task_default": (task, ws, title) => `Task ${task} (workstream ${ws}): ${title}. Read: mu task notes ${task} -w ${ws}`,
   "agent.spawn_name_hint": (name) => `hint: agent name "${name}" does not match the smallest-unused-suffix convention (<role>-<n>; e.g. worker-1, reviewer-2). Accepted; consider renaming if you spawn additional workers.
@@ -2097,12 +2097,12 @@ function say(key, ...facts) {
 // src/agents/spawn.ts
 import { execFile as execFile4 } from "child_process";
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, rmSync as rmSync3, statSync as statSync2 } from "fs";
-import { basename as basename2, dirname as dirname11, resolve as resolve3 } from "path";
+import { basename as basename2, dirname as dirname12, resolve as resolve3 } from "path";
 import { setTimeout as delay } from "timers/promises";
 import { promisify as promisify3 } from "util";
 
 // src/agents.ts
-import { dirname as dirname10 } from "path";
+import { dirname as dirname11 } from "path";
 
 // src/agent-state.ts
 import { accessSync, constants, existsSync as existsSync2 } from "fs";
@@ -2792,12 +2792,16 @@ var OWNED = (a) => `${a}.host IS NOT NULL AND ${a}.cwd IS NOT NULL AND ${a}.cwd
 var COLUMNS = `agent_id, workstream, workstream_id, workstream_created_at, name, pane_id, host, cwd,
        base, collected_head, aside, host_exec, host_repo, reason, preserved_at`;
 var NOW = "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
+var LEGACY_RECOVERY_TRIGGERS = [
+  "remote_recovery_agent_del",
+  "remote_recovery_workstream_del"
+];
 var REMOTE_RECOVERY_DDL = `
 -- remote_recovery: what a finalized remote worker row said about its
 -- worktree, written by triggers when the row is deleted (machine-local; see
 -- src/db-recovery.ts). No foreign key on purpose: it must outlive the agent,
--- its workstream and its host profile. host_exec / host_repo pin the
--- profile's identity when the profile existed. A receipt of the resource,
+-- its workstream and its host profile. host_exec pins the profile's
+-- identity when the profile existed; host_repo is the worktree's repo. A receipt of the resource,
 -- not a live channel.
 CREATE TABLE IF NOT EXISTS remote_recovery (
   agent_id             INTEGER PRIMARY KEY,
@@ -2817,7 +2821,7 @@ CREATE TABLE IF NOT EXISTS remote_recovery (
   preserved_at         TEXT NOT NULL
 );
 
-CREATE TRIGGER IF NOT EXISTS remote_recovery_agent_del
+CREATE TRIGGER IF NOT EXISTS remote_recovery_agent_del_v2
 AFTER DELETE ON agents
 WHEN ${OWNED("OLD")}
   AND EXISTS (SELECT 1 FROM workstreams WHERE id = OLD.workstream_id)
@@ -2826,19 +2830,19 @@ BEGIN
   SELECT OLD.id, ws.name, ws.id, ws.created_at, OLD.name, OLD.pane_id, OLD.host, OLD.cwd,
          OLD.base, OLD.collected_head, OLD.cwd || '.mu-removing-' || OLD.id,
          (SELECT exec FROM host_profiles WHERE name = OLD.host),
-         (SELECT repo FROM host_profiles WHERE name = OLD.host),
+         OLD.repo,
          ${REASON}, ${NOW}
     FROM workstreams ws WHERE ws.id = OLD.workstream_id;
 END;
 
-CREATE TRIGGER IF NOT EXISTS remote_recovery_workstream_del
+CREATE TRIGGER IF NOT EXISTS remote_recovery_workstream_del_v2
 BEFORE DELETE ON workstreams
 BEGIN
   INSERT OR IGNORE INTO remote_recovery (${COLUMNS})
   SELECT a.id, OLD.name, OLD.id, OLD.created_at, a.name, a.pane_id, a.host, a.cwd,
          a.base, a.collected_head, a.cwd || '.mu-removing-' || a.id,
          (SELECT exec FROM host_profiles WHERE name = a.host),
-         (SELECT repo FROM host_profiles WHERE name = a.host),
+         a.repo,
          'workstream-delete', ${NOW}
     FROM agents a
    WHERE a.workstream_id = OLD.id AND ${OWNED("a")};
@@ -3093,7 +3097,13 @@ function upgradeSchema(db) {
     throw err;
   }
 }
+function hostProfilesRepoRequired(db) {
+  const row = db.prepare(`SELECT "notnull" AS nn FROM pragma_table_info('host_profiles') WHERE name = 'repo'`).get();
+  return row?.nn === 1;
+}
 function applySchemaDdl(db) {
+  if (hostProfilesRepoRequired(db)) db.exec("DROP TABLE host_profiles");
+  for (const t of LEGACY_RECOVERY_TRIGGERS) db.exec(`DROP TRIGGER IF EXISTS ${t}`);
   db.exec(CURRENT_SCHEMA);
   for (const [table, column, ddl] of ADDED_COLUMNS) {
     if (!hasColumn(db, table, column)) db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
@@ -3165,6 +3175,8 @@ var ADDED_COLUMNS = [
   ["agents", "collected_head", "TEXT"],
   // The remote command gate's spawn-unique token (machine-local): its marker and result key.
   ["agents", "gate_token", "TEXT"],
+  // A remote worktree's repo, chosen per spawn (a host profile names a machine).
+  ["agents", "repo", "TEXT"],
   ["wait_registrations", "baselines_json", "TEXT NOT NULL DEFAULT '{}'"],
   ["task_auto", "enabled", "INTEGER NOT NULL DEFAULT 1 CHECK (enabled IN (0, 1))"],
   ...["request", "verdict", "agent"].map((c) => ["delegate_calls", c, "TEXT"]),
@@ -3182,6 +3194,8 @@ function schemaIsCurrent(db) {
   if (expected.tables.some((t) => !have.has(`table:${t}`))) return false;
   if (expected.triggers.some((t) => !have.has(`trigger:${t}`))) return false;
   if (ADDED_COLUMNS.some(([t, c]) => !hasColumn(db, t, c))) return false;
+  if (LEGACY_RECOVERY_TRIGGERS.some((t) => have.has(`trigger:${t}`))) return false;
+  if (hostProfilesRepoRequired(db)) return false;
   if (expected.indexes.some((i) => !have.has(`index:${i}`))) return false;
   for (const [name, sql] of expected.views) {
     if (have.get(`view:${name}`) !== sql) return false;
@@ -3400,6 +3414,7 @@ CREATE TABLE IF NOT EXISTS agents (
   spawner       TEXT,                           -- who spawned it: '<workstream>/<agent>' or 'pi:<session>' (machine-local); NULL: unknown
   host          TEXT,                           -- the remote host profile it runs on (machine-local); NULL: local
   collected_head TEXT,                          -- HEAD last collected from a remote worktree (machine-local)
+  repo          TEXT,                           -- a remote worktree's repo on its host, made absolute at spawn (machine-local); NULL: none
   gate_token    TEXT,                           -- remote command gate: spawn-unique token, also the key of its remote result record (machine-local); NULL: not a gate
   created_at    TEXT NOT NULL,
   updated_at    TEXT NOT NULL,
@@ -3517,6 +3532,8 @@ CREATE TABLE IF NOT EXISTS delegate_calls (
   request          TEXT,  -- spawn request (JSON)
   verdict          TEXT, agent TEXT  -- parsed label of a done answer; the agent that ran it
 );
+-- The dashboard's attention scan reads refused and recently failed calls each tick.
+CREATE INDEX IF NOT EXISTS idx_delegate_calls_state ON delegate_calls (state, updated_at);
 
 -- human_needs: the caller that recorded a kind=human task (machine-local).
 -- The task, its reason brief and its close are portable; who asked is not
@@ -3643,7 +3660,7 @@ CREATE TABLE IF NOT EXISTS host_profiles (
   shell        TEXT NOT NULL,
   exec         TEXT NOT NULL,
   fetch        TEXT NOT NULL,
-  repo         TEXT NOT NULL,
+  repo         TEXT,                           -- default remote repo for spawns without --root; NULL: none
   max_sessions INTEGER CHECK (max_sessions > 0)
 );
 
@@ -3871,20 +3888,20 @@ function compareHlc(a, b) {
   if (a > b) return 1;
   return 0;
 }
-function nextHlc(db, now = Date.now()) {
+function nextHlc(db, now2 = Date.now()) {
   const row = db.prepare(
     `UPDATE machine_identity
           SET last_wall    = MAX(last_wall, @now),
               last_counter = CASE WHEN @now > last_wall THEN 0 ELSE last_counter + 1 END
         WHERE id = 1
         RETURNING machine_id, last_wall, last_counter`
-  ).get({ now: Math.floor(now) });
+  ).get({ now: Math.floor(now2) });
   if (!row) throw new MachineIdentityMissingError();
   return formatHlc({ wallMs: row.last_wall, counter: row.last_counter, machineId: row.machine_id });
 }
-function receiveHlc(db, remoteHlc, now = Date.now()) {
+function receiveHlc(db, remoteHlc, now2 = Date.now()) {
   const remote = parseHlc(remoteHlc);
-  const wallNow = Math.floor(now);
+  const wallNow = Math.floor(now2);
   const read = prepareCached(
     db,
     "SELECT machine_id, last_wall, last_counter FROM machine_identity WHERE id = 1"
@@ -5847,8 +5864,10 @@ function respawnCommand(agent) {
   if (agent.host !== null) parts.push("--host", shellWord(agent.host));
   if (agent.role !== "full-access") parts.push("--role", shellWord(agent.role));
   if (agent.tab !== null) parts.push("--tab", shellWord(agent.tab));
-  if (agent.base !== null) parts.push("--worktree");
-  else if (agent.cwd !== null) parts.push("--cwd", shellWord(agent.cwd));
+  if (agent.base !== null) {
+    parts.push("--worktree");
+    if (agent.host !== null && agent.repo !== null) parts.push("--root", shellWord(agent.repo));
+  } else if (agent.cwd !== null) parts.push("--cwd", shellWord(agent.cwd));
   return parts.join(" ");
 }
 async function extensionOutdated(agent, sock, e) {
@@ -6198,8 +6217,8 @@ function mapMurmurState(token, since) {
 function parseSince(value) {
   return value !== void 0 && /^\d+$/.test(value) ? Number(value) : null;
 }
-async function readMurmur(now) {
-  if (murmurCache !== void 0 && now - murmurCache.at < MURMUR_CACHE_MS) {
+async function readMurmur(now2) {
+  if (murmurCache !== void 0 && now2 - murmurCache.at < MURMUR_CACHE_MS) {
     return murmurCache.stdout;
   }
   let stdout;
@@ -6208,7 +6227,7 @@ async function readMurmur(now) {
   } catch {
     stdout = null;
   }
-  murmurCache = { at: now, stdout };
+  murmurCache = { at: now2, stdout };
   return stdout;
 }
 function remotePanes(stdout) {
@@ -6505,7 +6524,9 @@ function addHost(db, p) {
   if (p.max_sessions !== null && !(Number.isInteger(p.max_sessions) && p.max_sessions > 0)) {
     throw new HostProfileError("--max-sessions must be a positive integer");
   }
-  if (p.repo.trim() === "") throw new HostProfileError("--repo must not be empty");
+  if (p.repo !== null && p.repo.trim() === "") {
+    throw new HostProfileError("--repo must not be empty");
+  }
   for (const f of ["shell", "exec", "fetch"]) {
     try {
       validateHostTemplate(p[f]);
@@ -6696,8 +6717,8 @@ function pidProvenGone(pid, start) {
     return e.code === "ESRCH";
   }
   if (start === null) return false;
-  const now = pidStart(pid);
-  return now !== null && now !== start;
+  const now2 = pidStart(pid);
+  return now2 !== null && now2 !== start;
 }
 function groupAlive(pgid, start) {
   try {
@@ -6706,8 +6727,8 @@ function groupAlive(pgid, start) {
     return e.code !== "ESRCH";
   }
   if (start === null) return true;
-  const now = pidStart(pgid);
-  return now === null || now === start;
+  const now2 = pidStart(pgid);
+  return now2 === null || now2 === start;
 }
 async function probeAttached(db, host, paneAlive3) {
   if (paneAlive3 === void 0) return [];
@@ -6834,6 +6855,7 @@ async function checkHost(db, host, opts = {}) {
     host,
     `check:${process.pid}`,
     async (profile, lease) => {
+      const root = opts.root ?? profile.repo ?? void 0;
       const step = async (name, cmd, good, unmet) => {
         let detail;
         let ok = false;
@@ -6843,7 +6865,8 @@ async function checkHost(db, host, opts = {}) {
             lease,
             profile,
             "exec",
-            { cmd, cwd: profile.repo },
+            // `.` without a repo: a template's `cd {cwd:sh}` stays in the login directory.
+            { cmd, cwd: root ?? "." },
             timeoutMs
           );
           const why = firstLine(r.stderr) || firstLine(r.stdout);
@@ -6858,12 +6881,11 @@ async function checkHost(db, host, opts = {}) {
         return ok;
       };
       if (await step("reachable", "true", () => "exec answered", "")) {
-        await step(
-          "repo",
-          `git -C ${remotePathWord(profile.repo)} rev-parse --git-dir`,
-          () => profile.repo,
-          ""
-        );
+        if (root === void 0) {
+          steps.push({ step: "repo", ok: null, detail: "skipped: no repo given (--root)" });
+        } else {
+          await step("repo", `git -C ${remotePathWord(root)} rev-parse --git-dir`, () => root, "");
+        }
         await step(
           "pi",
           login("pi --version"),
@@ -6903,7 +6925,7 @@ async function checkHost(db, host, opts = {}) {
     },
     opts
   );
-  return { host, ok: steps.every((s) => s.ok === true), steps };
+  return { host, ok: steps.every((s) => s.ok !== false), steps };
 }
 
 // src/op-context.ts
@@ -7031,15 +7053,15 @@ function reapAgentRow(db, agentId, name, opts = {}) {
     "INSERT INTO task_notes (task_id, author, content, created_at, kind) VALUES (?, 'reaper', ?, ?, 'note')"
   );
   for (const t of stuck) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    reopen.run(now, t.taskId);
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    reopen.run(now2, t.taskId);
     withOpContext(
       db,
       { intent: "task.note", actor: "reaper" },
       () => note.run(
         t.taskId,
         `[reaper] previous owner ${name} gone (agent removed); status reverted IN_PROGRESS \u2192 OPEN, owner cleared`,
-        now
+        now2
       )
     );
   }
@@ -7197,7 +7219,7 @@ function agentRevision(db, workstream, name, recoveryId) {
   if (recoveryId !== void 0) return recoveryRevision(db, workstream, name, recoveryId);
   const agent = db.prepare(
     `SELECT a.id, a.pane_id, a.cli, a.role, a.tab, a.cwd, a.base, a.command, a.command_source,
-              a.spawner, a.host, a.collected_head, a.gate_token, a.created_at
+              a.spawner, a.host, a.collected_head, a.repo, a.gate_token, a.created_at
          FROM agents a JOIN workstreams w ON w.id = a.workstream_id
         WHERE w.name = ? AND a.name = ?`
   ).get(workstream, name);
@@ -7504,8 +7526,8 @@ function taskIdFor(db, localId, workstream) {
   const row = db.prepare("SELECT id FROM tasks WHERE workstream_id = ? AND local_id = ?").get(wsId, localId);
   return row ? row.id : null;
 }
-function touchTask(db, taskId, now) {
-  const ts = now ?? (/* @__PURE__ */ new Date()).toISOString();
+function touchTask(db, taskId, now2) {
+  const ts = now2 ?? (/* @__PURE__ */ new Date()).toISOString();
   db.prepare("UPDATE tasks SET updated_at = ? WHERE id = ? AND updated_at < ?").run(ts, taskId, ts);
 }
 
@@ -7752,13 +7774,13 @@ function listTasksByOwnerCrossWorkstream(db, owner, opts = {}) {
 // src/tasks/edges.ts
 function dedupeBlockersById(blockers) {
   const seen = /* @__PURE__ */ new Set();
-  const canonical2 = [];
+  const canonical3 = [];
   for (const blocker of blockers) {
     if (seen.has(blocker.id)) continue;
     seen.add(blocker.id);
-    canonical2.push(blocker);
+    canonical3.push(blocker);
   }
-  return canonical2;
+  return canonical3;
 }
 function sameNumberSet(left, right) {
   if (left.length !== right.length) return false;
@@ -7891,13 +7913,13 @@ function addBlockEdgeImpl(db, workstream, blocked, blocker) {
   if (wouldCreateCycle(db, blockerId, blockedId)) {
     throw cycleErrorFor(db, blocker, blocked, blockerId, blockedId, blockedRow.workstreamName);
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const added = db.transaction(() => {
     const result = db.prepare(
       "INSERT INTO task_edges (from_task_id, to_task_id, created_at) SELECT ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM task_edges WHERE from_task_id = ? AND to_task_id = ?)"
-    ).run(blockerId, blockedId, now, blockerId, blockedId);
+    ).run(blockerId, blockedId, now2, blockerId, blockedId);
     if (result.changes > 0) {
-      touchTask(db, blockedId, now);
+      touchTask(db, blockedId, now2);
       return true;
     }
     return false;
@@ -7983,11 +8005,11 @@ function reparentTaskImpl(db, taskLocalId, blockers, scope) {
     const insertEdge = db.prepare(
       "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
     );
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
     for (const blockerId of blockerIds) {
-      insertEdge.run(blockerId, taskSurrogateId, now);
+      insertEdge.run(blockerId, taskSurrogateId, now2);
     }
-    touchTask(db, taskSurrogateId, now);
+    touchTask(db, taskSurrogateId, now2);
     return { removedEdges: removed.changes, addedEdges: blockerIds.length };
   }).immediate();
 }
@@ -8899,9 +8921,9 @@ async function teardownWorkstream(db, opts) {
     db,
     { intent: "workstream.teardown", group: "new" },
     () => db.transaction(() => {
-      const now = workstreamRevision(db, opts.workstream);
-      if (now !== opts.ifRevision) {
-        throw new WorkstreamRevisionMismatchError(opts.workstream, opts.ifRevision, now);
+      const now2 = workstreamRevision(db, opts.workstream);
+      if (now2 !== opts.ifRevision) {
+        throw new WorkstreamRevisionMismatchError(opts.workstream, opts.ifRevision, now2);
       }
       for (const a of dead) {
         if (!sameRow2.get(a.incarnation, a.name, a.paneId, opts.workstream)) continue;
@@ -9110,7 +9132,7 @@ function addTaskImpl(db, opts) {
     if (existing) {
       throw new TaskExistsError(opts.localId);
     }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const insertResult = db.prepare(
       `INSERT INTO tasks (workstream_id, local_id, title, status, substate, kind, wave, impact, effort_days, scored, created_at, updated_at)
          VALUES (?, ?, ?, 'OPEN', ?, ?, ?, ?, ?, ?, ?, ?)`
@@ -9124,8 +9146,8 @@ function addTaskImpl(db, opts) {
       opts.impact ?? DEFAULT_IMPACT,
       opts.effortDays ?? DEFAULT_EFFORT_DAYS,
       opts.impact !== void 0 || opts.effortDays !== void 0 ? 1 : 0,
-      now,
-      now
+      now2,
+      now2
     );
     const newTaskId = Number(insertResult.lastInsertRowid);
     if (opts.blockedBy && opts.blockedBy.length > 0) {
@@ -9149,7 +9171,7 @@ function addTaskImpl(db, opts) {
         "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
       );
       for (const blocker of canonicalBlockers) {
-        insertEdge.run(blocker.id, newTaskId, now);
+        insertEdge.run(blocker.id, newTaskId, now2);
       }
     }
     const row = getTask(db, opts.localId, opts.workstream);
@@ -9204,7 +9226,7 @@ function addBlocksEdges(db, input, blocks, workstream) {
     }
     umbrellas.set(row.id, local);
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const insertEdge = db.prepare(
     "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
   );
@@ -9215,10 +9237,10 @@ function addBlocksEdges(db, input, blocks, workstream) {
       if (wouldCreateCycle(db, newId, umbrellaId)) {
         throw cycleErrorFor(db, t.id, umbrella, newId, umbrellaId, workstream);
       }
-      insertEdge.run(newId, umbrellaId, now);
+      insertEdge.run(newId, umbrellaId, now2);
     }
   }
-  for (const umbrellaId of umbrellas.keys()) touchTask(db, umbrellaId, now);
+  for (const umbrellaId of umbrellas.keys()) touchTask(db, umbrellaId, now2);
 }
 function lookupEdgeTask(db, wsId, localId, workstream) {
   const row = db.prepare(
@@ -9251,18 +9273,18 @@ function insertNote(db, taskLocalId, content, opts, touch = true) {
   }
   const taskId = taskIdFor(db, task.name, task.workstreamName);
   if (taskId === null) throw new TaskNotFoundError(taskLocalId, task.workstreamName);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   db.transaction(() => {
     const r = db.prepare(
       "INSERT INTO task_notes (task_id, author, content, created_at, kind) VALUES (?, ?, ?, ?, ?)"
-    ).run(taskId, opts.author ?? null, content, now, opts.kind ?? "note");
-    if (touch) touchTask(db, taskId, now);
+    ).run(taskId, opts.author ?? null, content, now2, opts.kind ?? "note");
+    if (touch) touchTask(db, taskId, now2);
     return r;
   }).immediate();
   return {
     author: opts.author ?? null,
     content,
-    createdAt: now,
+    createdAt: now2,
     kind: opts.kind ?? "note"
   };
 }
@@ -9730,7 +9752,7 @@ async function claimTaskImpl(db, localId, opts) {
           throw new ClaimerNotRegisteredError(agentName, null);
         }
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const now2 = (/* @__PURE__ */ new Date()).toISOString();
       let result;
       try {
         result = db.prepare(
@@ -9744,7 +9766,7 @@ async function claimTaskImpl(db, localId, opts) {
           WHERE local_id = ?
             AND workstream_id = (SELECT id FROM workstreams WHERE name = ?)
             AND (owner_id IS NULL OR owner_id = ?)`
-        ).run(claimerRow.id, now, localId, opts.workstream, claimerRow.id);
+        ).run(claimerRow.id, now2, localId, opts.workstream, claimerRow.id);
       } catch (err) {
         if (err instanceof Error && err.message === GUARD_ALREADY_OWNED) {
           throw new TaskAlreadyOwnedError(localId, before.ownerName ?? "<unknown>");
@@ -9800,7 +9822,7 @@ async function claimSelf(db, localId, opts) {
       if (!before) throw new TaskNotFoundError(localId, opts.workstream);
       assertTaskRevision(db, before.workstreamName, localId, opts.ifRevision);
       assertNotParked(before, opts);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const now2 = (/* @__PURE__ */ new Date()).toISOString();
       const result = db.prepare(
         `UPDATE tasks
             SET status = CASE WHEN status = 'OPEN' THEN 'IN_PROGRESS' ELSE status END,
@@ -9809,7 +9831,7 @@ async function claimSelf(db, localId, opts) {
           WHERE local_id = ?
             AND workstream_id = (SELECT id FROM workstreams WHERE name = ?)
             AND owner_id IS NULL`
-      ).run(now, localId, before.workstreamName);
+      ).run(now2, localId, before.workstreamName);
       if (result.changes === 0) {
         throw new TaskAlreadyOwnedError(localId, before.ownerName ?? "<unknown>");
       }
@@ -9977,8 +9999,18 @@ function reclaimLines() {
   ];
 }
 async function prepareRemote(db, lease, profile, opts) {
-  const root = remotePathWord(profile.repo);
-  const answer = `printf 'MU_WT %s %s\\n' "$base" "$(cd "$wt" && pwd -P)"`;
+  if (opts.worktree && opts.root === void 0) {
+    throw new RemotePrepareError(
+      profile.name,
+      "creating the remote worktree failed",
+      `host ${profile.name} has no default repo: pass --root <remote repo path>`
+    );
+  }
+  const root = remotePathWord(opts.root ?? "~");
+  const answer = [
+    `r=$(cd "$root" && pwd -P) || exit 5`,
+    `printf 'MU_REPO %s\\nMU_WT %s %s\\n' "$(printf '%s' "$r" | od -An -v -tx1 | tr -d ' \\n')" "$base" "$(cd "$wt" && pwd -P)"`
+  ].join("\n");
   const body = opts.worktree ? [
     `root=${root}`,
     `wt=${remoteWorktreeWord(opts.workstream, opts.name)}`,
@@ -9993,13 +10025,15 @@ fi` : `[ ! -e "$wt" ] || { echo "$wt already exists" >&2; exit 4; }`,
     `git -C "$root" worktree add --detach "$wt" "$base" >&2 || undo`,
     `gd=$(git -C "$wt" rev-parse --absolute-git-dir) && : > "$gd/${PREPARED_MARK}" || undo`,
     answer
-  ].join("\n") : `cd ${remotePathWord(opts.cwd ?? profile.repo)} && printf 'MU_CWD %s\\n' "$(pwd -P)"`;
+  ].join("\n") : `cd ${remotePathWord(opts.cwd ?? opts.root ?? "~")} && printf 'MU_CWD %s\\n' "$(pwd -P)"`;
   const r = await runLeasedTemplate(
     db,
     lease,
     profile,
     "exec",
-    { cmd: script(body), cwd: profile.repo },
+    // `.`, not `~`, without a repo: a template's `cd {cwd:sh}` stays where the login shell
+    // started (a quoted `~` never expands); the script itself resolves --cwd and "$HOME".
+    { cmd: script(body), cwd: opts.root ?? "." },
     REMOTE_PREPARE_TIMEOUT_MS
   );
   const what = opts.worktree ? "creating the remote worktree failed" : "the remote cwd is unreachable";
@@ -10021,18 +10055,28 @@ fi` : `[ ! -e "$wt" ] || { echo "$wt already exists" >&2; exit 4; }`,
   }
   const lines = r.stdout.split("\n").map((l) => l.trim());
   if (opts.worktree) {
+    const repo = decodeRepo(
+      [...lines].reverse().find((l) => /^MU_REPO [0-9a-f]+$/.test(l))?.slice("MU_REPO ".length)
+    );
     for (const l of lines.reverse()) {
       const m = /^MU_WT ([0-9a-f]{40,64}) (\/.+)$/.exec(l);
-      if (m?.[1] !== void 0 && m[2] !== void 0) return { cwd: m[2], base: m[1] };
+      if (m?.[1] !== void 0 && m[2] !== void 0 && repo !== void 0) {
+        return { cwd: m[2], base: m[1], repo };
+      }
     }
   } else {
     for (const l of lines.reverse()) {
       const m = /^MU_CWD (\/.+)$/.exec(l);
-      if (m?.[1] !== void 0) return { cwd: m[1], base: null };
+      if (m?.[1] !== void 0) return { cwd: m[1], base: null, repo: null };
     }
   }
   throw new RemotePrepareError(profile.name, what, `the host's answer named no path${lost}`);
 }
+function decodeRepo(hex) {
+  if (hex === void 0 || hex.length % 2 !== 0) return void 0;
+  const path = Buffer.from(hex, "hex").toString("utf8");
+  return path.startsWith("/") ? path : void 0;
+}
 async function removeRemoteWorktree(db, host, holder, wt) {
   const p = shellQuote(wt.path);
   const body = [
@@ -10089,8 +10133,8 @@ function quiescenceLines(probe, force = false) {
   ];
 }
 async function closeRemoteWorktree(db, agent, opts = {}) {
-  const { name, workstreamName: ws, host, cwd: path, base, collectedHead } = agent;
-  if (host === null || path === null || base === null) {
+  const { name, workstreamName: ws, host, cwd: path, base, collectedHead, repo } = agent;
+  if (host === null || path === null || base === null || repo === null) {
     throw new Error(say("remote.no_worktree", name));
   }
   const asidePath = asideOf(path, agent.incarnation);
@@ -10104,7 +10148,7 @@ async function closeRemoteWorktree(db, agent, opts = {}) {
     `close:${ws}/${name}`,
     async (profile, lease) => {
       opts.checkProfile?.(profile);
-      const root = remotePathWord(profile.repo);
+      const root = shellQuote(repo);
       const wt = shellQuote(path);
       const aside = shellQuote(asidePath);
       const run2 = async (body) => {
@@ -10113,7 +10157,7 @@ async function closeRemoteWorktree(db, agent, opts = {}) {
           lease,
           profile,
           "exec",
-          { cmd: script(body), cwd: profile.repo },
+          { cmd: script(body), cwd: repo },
           REMOTE_PREPARE_TIMEOUT_MS
         );
         if (r2.exitCode === null) refuse("unreadable", `host ${host} timed out`);
@@ -10350,13 +10394,14 @@ function assertRecoveryProfile(rec, profile) {
     ]);
   };
   if (profile === void 0) refuse(`host ${rec.host} has no profile now`);
-  if (rec.hostExec === null || rec.hostRepo === null) {
+  if (rec.hostExec === null) {
     refuse(
       `host ${rec.host} had no profile when the agent was removed: nothing proves the profile now named ${rec.host} reaches that worktree`
     );
   }
-  if (profile?.exec !== rec.hostExec || profile.repo !== rec.hostRepo) {
-    refuse(`host ${rec.host}'s profile changed since the agent was removed (exec or repo differs)`);
+  if (rec.hostRepo === null) refuse(`recovery ${rec.agentId} names no repo for its worktree`);
+  if (profile?.exec !== rec.hostExec) {
+    refuse(`host ${rec.host}'s profile changed since the agent was removed (exec differs)`);
   }
 }
 function assertRecoveryUsable(db, rec) {
@@ -10398,7 +10443,7 @@ function assertRecoveryUsable(db, rec) {
   }
   assertRecoveryProfile(
     rec,
-    db.prepare("SELECT exec, repo FROM host_profiles WHERE name = ?").get(rec.host)
+    db.prepare("SELECT exec FROM host_profiles WHERE name = ?").get(rec.host)
   );
 }
 function assertRecoveryUnchanged(db, rec) {
@@ -10649,16 +10694,16 @@ function registerOwnedWait(db, caller, refs) {
     for (const r of add) if (r.kind === "agent") unmark.run(caller, doneKey(r.workstream, r.id));
     const baselines = { ...old?.baselines ?? {} };
     for (const [k, b] of incoming) baselines[k] = mergeBaseline(baselines[k], b);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const baselinesJson = JSON.stringify(baselines);
     if (row === void 0) {
       db.prepare(
         "INSERT INTO wait_registrations (caller, refs_json, state, generation, updated_at, baselines_json) VALUES (?, ?, 'armed', 0, ?, ?)"
-      ).run(caller, JSON.stringify(merged), now, baselinesJson);
+      ).run(caller, JSON.stringify(merged), now2, baselinesJson);
     } else if (merged.length !== have.length || baselinesJson !== row.baselines_json) {
       db.prepare(
         "UPDATE wait_registrations SET refs_json = ?, baselines_json = ?, updated_at = ? WHERE caller = ?"
-      ).run(JSON.stringify(merged), baselinesJson, now, caller);
+      ).run(JSON.stringify(merged), baselinesJson, now2, caller);
     }
     const after = select(db, caller);
     if (after === void 0) throw new WaitRegistrationError("wait registration vanished");
@@ -10836,6 +10881,7 @@ async function closeRecovery(db, rec, opts) {
       cwd: rec.cwd,
       base: rec.base,
       collectedHead: rec.collectedHead,
+      repo: rec.hostRepo,
       // The ORIGINAL registry incarnation: the aside path derives from it.
       incarnation: rec.agentId
     },
@@ -10933,7 +10979,7 @@ async function readGate(db, agent) {
       host,
       "exec",
       `gate:${agent.workstreamName}/${agent.name}`,
-      { cmd: readCommand(token), cwd: getHost(db, host).repo },
+      { cmd: readCommand(token), cwd: "." },
       { paneAlive: localPaneAlive }
     );
   } catch (e) {
@@ -10961,7 +11007,7 @@ async function cleanGateResult(db, agent) {
       host,
       "exec",
       `gate-clean:${agent.workstreamName}/${agent.name}`,
-      { cmd: cleanCommand(token), cwd: getHost(db, host).repo },
+      { cmd: cleanCommand(token), cwd: "." },
       { paneAlive: localPaneAlive }
     );
     return r.exitCode === 0;
@@ -11201,12 +11247,12 @@ async function previewClose(db, name, opts) {
     const row = worktreeOf(db, opts.workstream, name, agent);
     const state = row === void 0 ? void 0 : await worktreeState(row.path, row.base, row.root);
     const preview = db.transaction(() => {
-      const now = getAgentForCleanup(db, name, opts.workstream);
-      const nowRow = worktreeOf(db, opts.workstream, name, now);
-      if (now?.incarnation !== agent?.incarnation || now?.paneId !== agent?.paneId || nowRow?.path !== row?.path) {
+      const now2 = getAgentForCleanup(db, name, opts.workstream);
+      const nowRow = worktreeOf(db, opts.workstream, name, now2);
+      if (now2?.incarnation !== agent?.incarnation || now2?.paneId !== agent?.paneId || nowRow?.path !== row?.path) {
         return void 0;
       }
-      const rec = opts.recoveryId !== void 0 || now === void 0 && nowRow === void 0 ? selectRemoteRecovery(db, opts.workstream, name, opts.recoveryId) : void 0;
+      const rec = opts.recoveryId !== void 0 || now2 === void 0 && nowRow === void 0 ? selectRemoteRecovery(db, opts.workstream, name, opts.recoveryId) : void 0;
       if (rec === void 0 && opts.recoveryId !== void 0) {
         return {
           agentName: name,
@@ -11243,13 +11289,13 @@ async function previewClose(db, name, opts) {
       return {
         agentName: name,
         workstream: opts.workstream,
-        kind: now ? "agent" : nowRow ? "orphan-worktree" : "none",
+        kind: now2 ? "agent" : nowRow ? "orphan-worktree" : "none",
         revision: opts.recoveryId === void 0 ? agentRevision(db, opts.workstream, name) : 0,
-        incarnation: now?.incarnation ?? null,
-        paneId: now?.paneId ?? null,
-        ownedTasks: now ? ownedTasksOf(db, now) : [],
+        incarnation: now2?.incarnation ?? null,
+        paneId: now2?.paneId ?? null,
+        ownedTasks: now2 ? ownedTasksOf(db, now2) : [],
         worktree: nowRow && state ? { path: nowRow.path, state } : null,
-        remote: remoteOf(now),
+        remote: remoteOf(now2),
         recovery: null,
         refusesDirty: state === "dirty" && !discard,
         discard,
@@ -11295,8 +11341,8 @@ async function closeLocked(db, name, opts) {
   const mux = await activeMux().catch(() => void 0);
   const running = await runInFlight(agent);
   const replaced = () => {
-    const now = getAgentForCleanup(db, name, opts.workstream);
-    return now !== void 0 && !sameIncarnation(now, agent);
+    const now2 = getAgentForCleanup(db, name, opts.workstream);
+    return now2 !== void 0 && !sameIncarnation(now2, agent);
   };
   if (replaced()) throw new AgentReplacedError(name, opts.workstream);
   fence();
@@ -11551,8 +11597,417 @@ async function watchAgentRun(agent, sock, signal, opts) {
   return { initial, afterRuns, settled };
 }
 
-// src/agents/receipts.ts
+// src/delegates.ts
 import { createHash as createHash5 } from "crypto";
+import { dirname as dirname10, join as join8 } from "path";
+
+// src/delegate-verdict.ts
+var VERDICT_LABELS = ["CONFIRMED", "REFUTED", "UNVERIFIED"];
+function formatElapsed(ms) {
+  const t = Math.max(0, Math.round(ms / 1e3));
+  if (t < 60) return `${t}s`;
+  const m = Math.floor(t / 60);
+  if (m < 60) return `${m}m ${String(t % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
+}
+var VERDICT_LINE2 = /^(?:\w+: )?VERDICT:/;
+var LABEL_RE = new RegExp(`\\b(${VERDICT_LABELS.join("|")})\\b`);
+function firstVerdictLine(lines) {
+  return lines.findIndex((l) => VERDICT_LINE2.test(l));
+}
+function verdictLineLabel(line) {
+  if (!VERDICT_LINE2.test(line)) return null;
+  const after = line.slice(line.indexOf("VERDICT:") + "VERDICT:".length);
+  return LABEL_RE.exec(after)?.[1];
+}
+function parseVerdict(answer) {
+  const lines = answer.trimEnd().split("\n");
+  const at = firstVerdictLine(lines);
+  if (at < 0) return void 0;
+  return verdictLineLabel(lines[at] ?? "") ?? void 0;
+}
+function recordNote(label, name, outcome, lastText, elapsedMs) {
+  if (outcome !== "done" || !lastText?.trim())
+    return `REFUTER ${label}: no verdict (${outcome === "done" ? "empty" : outcome ?? "no result"})`;
+  const lines = lastText.trimEnd().split("\n");
+  const at = firstVerdictLine(lines);
+  const body = at >= 0 ? lines.slice(at).join("\n") : `NO VERDICT LINE: ${lastText.trimEnd()}`;
+  return `REFUTER ${label} (${name}, ${formatElapsed(elapsedMs)}):
+${body}`;
+}
+
+// src/delegates.ts
+function delegateSessionDir(dbPath, workstream, task) {
+  return join8(dirname10(dbPath), "delegate-sessions", workstream, task);
+}
+function delegateProcessDir(dbPath, callId) {
+  return join8(
+    dirname10(dbPath),
+    "delegate-process",
+    createHash5("sha256").update(callId).digest("hex").slice(0, 16)
+  );
+}
+var TERMINAL_DELEGATE_STATES = ["done", "failed", "cancelled"];
+var TERMINAL = TERMINAL_DELEGATE_STATES;
+var isTerminal = (s) => TERMINAL.includes(s);
+var DelegateCallConflictError = class extends Error {
+  constructor(callId, field) {
+    super(say("delegate.conflict", callId, field));
+    this.callId = callId;
+    this.field = field;
+  }
+  callId;
+  field;
+  name = "DelegateCallConflictError";
+};
+var DelegateStateError = class extends Error {
+  constructor(callId, from, to) {
+    super(say("delegate.state", callId, from, to));
+    this.callId = callId;
+    this.from = from;
+    this.to = to;
+  }
+  callId;
+  from;
+  to;
+  name = "DelegateStateError";
+};
+var DelegateNotFoundError = class extends Error {
+  constructor(callId) {
+    super(say("delegate.not_found", callId));
+    this.callId = callId;
+  }
+  callId;
+  name = "DelegateNotFoundError";
+};
+var SELECT_CALL = `SELECT d.*, t.local_id AS local_id, w.name AS workstream, t.wave AS wave
+  FROM delegate_calls d
+  JOIN tasks t ON t.id = d.task_id
+  JOIN workstreams w ON w.id = t.workstream_id`;
+function rowOf(r) {
+  let request = { text: "" };
+  try {
+    if (r.request) request = JSON.parse(r.request);
+  } catch {
+  }
+  return {
+    callId: r.call_id,
+    task: r.local_id,
+    workstream: r.workstream,
+    caller: r.caller,
+    state: r.state,
+    wave: r.wave,
+    record: r.record_workstream !== null && r.record_task !== null ? { workstream: r.record_workstream, task: r.record_task, label: r.record_label } : null,
+    request,
+    agent: r.agent,
+    verdict: r.verdict ?? null,
+    error: r.error,
+    updatedAt: r.updated_at
+  };
+}
+function getDelegateCall(db, callId) {
+  const r = db.prepare(`${SELECT_CALL} WHERE d.call_id = ?`).get(callId);
+  return r ? rowOf(r) : void 0;
+}
+function mustGet(db, callId) {
+  const row = getDelegateCall(db, callId);
+  if (!row) throw new DelegateNotFoundError(callId);
+  return row;
+}
+function listDelegates(db, caller, workstream, opts = {}) {
+  const where = [];
+  const args = [];
+  if (caller !== void 0) {
+    where.push("d.caller = ?");
+    args.push(caller);
+  }
+  if (workstream !== void 0) {
+    where.push("w.name = ?");
+    args.push(workstream);
+  }
+  if (opts.wave !== void 0) {
+    where.push("t.wave = ?");
+    args.push(opts.wave);
+  }
+  if (opts.states !== void 0) {
+    where.push(`d.state IN (${opts.states.map(() => "?").join(",")})`);
+    args.push(...opts.states);
+  }
+  if (opts.taskStatuses !== void 0) {
+    where.push(`t.status IN (${opts.taskStatuses.map(() => "?").join(",")})`);
+    args.push(...opts.taskStatuses);
+  }
+  if (opts.updatedAfter !== void 0) {
+    where.push("d.updated_at > ?");
+    args.push(opts.updatedAfter);
+  }
+  const sql = `${SELECT_CALL}${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY d.task_id`;
+  return db.prepare(sql).all(...args).map(rowOf);
+}
+function listDelegatesOf(db, callers, workstream, opts = {}) {
+  const set = [...new Set(callers)];
+  if (set.length === 0) return [];
+  const where = [`d.caller IN (${set.map(() => "?").join(",")})`];
+  const args = [...set];
+  if (workstream !== void 0) {
+    where.push("w.name = ?");
+    args.push(workstream);
+  }
+  if (opts.wave !== void 0) {
+    where.push("t.wave = ?");
+    args.push(opts.wave);
+  }
+  const sql = `${SELECT_CALL} WHERE ${where.join(" AND ")} ORDER BY d.task_id`;
+  return db.prepare(sql).all(...args).map(rowOf);
+}
+function canonical2(v) {
+  if (Array.isArray(v)) return `[${v.map(canonical2).join(",")}]`;
+  if (typeof v === "object" && v !== null) {
+    const o = v;
+    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonical2(o[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(v);
+}
+function taskIdFor2(callId, label) {
+  const stem = (label ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 20).replace(/-+$/, "");
+  const h = createHash5("sha256").update(callId).digest("hex").slice(0, 8);
+  return `delegate_${stem ? `${stem}_` : ""}${h}`;
+}
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+function registerDelegateCall(db, opts) {
+  const state = opts.state ?? "queued";
+  return withOpContext(
+    db,
+    { intent: "delegate.register", actor: opts.caller, group: "new" },
+    () => db.transaction(() => {
+      const existing = getDelegateCall(db, opts.callId);
+      if (existing) {
+        const same = (field, a, b) => {
+          if (canonical2(a) !== canonical2(b))
+            throw new DelegateCallConflictError(opts.callId, field);
+        };
+        same("caller", existing.caller, opts.caller);
+        same("workstream", existing.workstream, opts.workstream);
+        same("wave", existing.wave, opts.wave ?? null);
+        same(
+          "record target",
+          existing.record ? { workstream: existing.record.workstream, task: existing.record.task } : null,
+          opts.record ?? null
+        );
+        same("request", existing.request, opts.request);
+        return { call: existing, created: false };
+      }
+      if (opts.record && !getTask(db, opts.record.task, opts.record.workstream))
+        throw new TaskNotFoundError(opts.record.task, opts.record.workstream);
+      const local = taskIdFor2(opts.callId, opts.request.label);
+      const headline = (opts.request.label ?? opts.request.text).replace(/\s+/g, " ").trim();
+      addTask(db, {
+        localId: local,
+        workstream: opts.workstream,
+        title: `delegate: ${headline.slice(0, 60)}`,
+        kind: "delegate",
+        ...opts.wave !== void 0 ? { wave: opts.wave } : {}
+      });
+      addNote(db, local, opts.request.text, {
+        workstream: opts.workstream,
+        kind: "brief",
+        author: opts.caller,
+        group: "inherit"
+      });
+      if (state !== "starting")
+        setTaskStatus(db, local, "OPEN", { workstream: opts.workstream, substate: "parked" });
+      const taskId = db.prepare(
+        "SELECT t.id AS id FROM tasks t JOIN workstreams w ON w.id = t.workstream_id WHERE w.name = ? AND t.local_id = ?"
+      ).get(opts.workstream, local).id;
+      db.prepare(
+        `INSERT INTO delegate_calls
+               (task_id, caller, call_id, state, record_workstream, record_task, record_label, updated_at, request)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        taskId,
+        opts.caller,
+        opts.callId,
+        state,
+        opts.record?.workstream ?? null,
+        opts.record?.task ?? null,
+        opts.request.label ?? null,
+        now(),
+        canonical2(opts.request)
+      );
+      return { call: mustGet(db, opts.callId), created: true };
+    }).immediate()
+  );
+}
+var MOVES = {
+  queued: ["refused"],
+  starting: ["queued", "refused"],
+  running: ["starting"],
+  refused: ["queued", "starting"]
+};
+function markDelegate(db, callId, to, extra = {}) {
+  const row = mustGet(db, callId);
+  const from = MOVES[to] ?? [];
+  if (!from.includes(row.state)) throw new DelegateStateError(callId, row.state, to);
+  return withOpContext(
+    db,
+    { intent: `delegate.${to}`, actor: row.caller, group: "new" },
+    () => db.transaction(() => {
+      const r = db.prepare(
+        `UPDATE delegate_calls
+                SET state = ?, updated_at = ?, agent = COALESCE(?, agent),
+                    error = CASE WHEN ? = 'refused' THEN COALESCE(?, error) ELSE NULL END
+              WHERE call_id = ? AND state = ?`
+      ).run(to, now(), extra.agent ?? null, to, extra.error ?? null, callId, row.state);
+      if (r.changes !== 1) throw new DelegateStateError(callId, mustGet(db, callId).state, to);
+      if (to === "starting")
+        setTaskStatus(db, row.task, "OPEN", { workstream: row.workstream, substate: "todo" });
+      if (to === "refused")
+        setTaskStatus(db, row.task, "OPEN", { workstream: row.workstream, substate: "parked" });
+      return mustGet(db, callId);
+    }).immediate()
+  );
+}
+function closedBy(db, task, workstream) {
+  const row = db.prepare(
+    `SELECT n.author AS author FROM task_notes n
+         JOIN tasks t ON t.id = n.task_id JOIN workstreams w ON w.id = t.workstream_id
+        WHERE w.name = ? AND t.local_id = ? AND t.status = 'CLOSED' AND n.kind = 'close'
+        ORDER BY n.id DESC LIMIT 1`
+  ).get(workstream, task);
+  return row?.author ?? null;
+}
+function finishText(outcome, text) {
+  if (outcome === "done") return text ?? "";
+  return `no answer (${outcome})${text?.trim() ? `
+
+${text.trimEnd()}` : ""}`;
+}
+function finishDelegate(db, callId, opts) {
+  const before = mustGet(db, callId);
+  const unchanged = (row) => ({
+    changed: false,
+    state: row.state,
+    task: row.task,
+    record: row.record ? { workstream: row.record.workstream, task: row.record.task } : null,
+    recorded: false,
+    verdict: row.verdict
+  });
+  if (isTerminal(before.state)) return unchanged(before);
+  db.prepare(
+    "UPDATE delegate_calls SET state = 'recording', updated_at = ? WHERE call_id = ? AND state NOT IN ('done','failed','cancelled')"
+  ).run(now(), callId);
+  const outcome = opts.outcome === "done" && !opts.text?.trim() ? "empty" : opts.outcome;
+  const answered = outcome === "done";
+  const cancelled = outcome === "cancelled";
+  const label = before.record?.label ?? before.request.label ?? opts.author;
+  const verdict = answered ? parseVerdict(opts.text ?? "") ?? null : null;
+  const record = before.record ? { workstream: before.record.workstream, task: before.record.task } : null;
+  const report = finishText(outcome, opts.text);
+  const wantRecord = opts.record !== false;
+  const write = (recordIt, error) => withOpContext(
+    db,
+    { intent: "delegate.finish", actor: opts.author, group: "new" },
+    () => db.transaction(() => {
+      const cur = mustGet(db, callId);
+      if (isTerminal(cur.state)) return unchanged(cur);
+      if (recordIt && record)
+        addNote(
+          db,
+          record.task,
+          recordNote(label, opts.author, outcome, opts.text, opts.elapsedMs ?? 0),
+          {
+            workstream: record.workstream,
+            kind: "verdict",
+            author: opts.author,
+            group: "inherit"
+          }
+        );
+      const ok = answered && error === void 0;
+      const state = ok ? "done" : cancelled ? "cancelled" : "failed";
+      const selfClosed = cur.agent !== null && closedBy(db, cur.task, cur.workstream) === cur.agent;
+      if (selfClosed)
+        addNote(db, cur.task, report, {
+          workstream: cur.workstream,
+          kind: "report",
+          author: opts.author,
+          group: "inherit"
+        });
+      closeTask(db, cur.task, {
+        workstream: cur.workstream,
+        author: opts.author,
+        group: "inherit",
+        ...selfClosed ? {} : { report },
+        as: ok ? "done" : cancelled ? "wontfix" : "rejected",
+        ...ok ? { evidence: `answered ${verdict ?? "with no VERDICT line"} (call ${callId})` } : { why: error ?? `${outcome}: no answer (call ${callId})` }
+      });
+      db.prepare(
+        "UPDATE delegate_calls SET state = ?, verdict = ?, error = ?, updated_at = ? WHERE call_id = ?"
+      ).run(state, ok ? verdict : null, error ?? null, now(), callId);
+      return {
+        changed: true,
+        state,
+        task: cur.task,
+        record,
+        recorded: recordIt && record !== null,
+        verdict: ok ? verdict : null,
+        ...error !== void 0 ? { error } : {}
+      };
+    }).immediate()
+  );
+  try {
+    return write(wantRecord);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return write(
+      false,
+      `record ${record ? `${record.workstream}/${record.task} ` : ""}failed: ${msg}`
+    );
+  }
+}
+function verdictTally(db, workstream, wave, callers) {
+  return tallyCalls(
+    callers === void 0 ? listDelegates(db, void 0, workstream, { wave }) : listDelegatesOf(db, callers, workstream, { wave })
+  );
+}
+function tallyCalls(calls) {
+  const out = { findings: [], queued: 0, running: 0, refused: [] };
+  const byId = /* @__PURE__ */ new Map();
+  for (const c of calls) {
+    const id = c.record ? `${c.record.workstream}/${c.record.task}` : `${c.workstream}/${c.task}`;
+    let f = byId.get(id);
+    if (!f) {
+      f = { id, confirmed: 0, refuted: 0, unverified: 0, pending: 0 };
+      byId.set(id, f);
+      out.findings.push(f);
+    }
+    switch (c.state) {
+      case "done":
+        if (c.verdict === "CONFIRMED") f.confirmed++;
+        else if (c.verdict === "REFUTED") f.refuted++;
+        else f.unverified++;
+        break;
+      case "failed":
+      case "cancelled":
+        f.unverified++;
+        break;
+      case "refused":
+        f.pending++;
+        out.refused.push(c.callId);
+        break;
+      case "queued":
+        f.pending++;
+        out.queued++;
+        break;
+      default:
+        f.pending++;
+        out.running++;
+    }
+  }
+  return out;
+}
+
+// src/agents/receipts.ts
+import { createHash as createHash6 } from "crypto";
 var fromRaw2 = (r) => ({
   taskId: r.task_id,
   attemptKey: r.attempt_key,
@@ -11573,19 +12028,20 @@ var fromRaw2 = (r) => ({
 function requestSha(req) {
   const parts = [req.name, req.nextFree, req.text];
   if (req.host !== void 0) parts.push(req.host);
-  return createHash5("sha256").update(JSON.stringify(parts)).digest("hex");
+  if (req.host !== void 0 && req.root !== void 0) parts.push({ root: req.root });
+  return createHash6("sha256").update(JSON.stringify(parts)).digest("hex");
 }
 function getReceipt(db, taskId, attemptKey) {
   const row = db.prepare("SELECT * FROM spawn_receipts WHERE task_id = ? AND attempt_key = ?").get(taskId, attemptKey);
   return row ? fromRaw2(row) : void 0;
 }
 function reserveReceipt(db, r) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   db.prepare(
     `INSERT INTO spawn_receipts
        (task_id, attempt_key, name, workstream, request_sha, msg_id, state, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, 'reserved', ?, ?)`
-  ).run(r.taskId, r.attemptKey, r.name, r.workstream, r.requestSha, r.msgId, now, now);
+  ).run(r.taskId, r.attemptKey, r.name, r.workstream, r.requestSha, r.msgId, now2, now2);
   const row = getReceipt(db, r.taskId, r.attemptKey);
   if (row === void 0) throw new Error("spawn receipt vanished after reservation");
   return row;
@@ -11656,19 +12112,15 @@ async function tryPinBrief(db, req) {
 }
 function stagedOf(db, row) {
   if (row.host !== null) {
-    if (row.cwd === null || row.base === null) return void 0;
-    try {
-      return {
-        path: row.cwd,
-        base: row.base,
-        root: getHost(db, row.host).repo,
-        createdAt: row.createdAt,
-        incarnation: row.incarnation,
-        host: row.host
-      };
-    } catch {
-      return void 0;
-    }
+    if (row.cwd === null || row.base === null || row.repo === null) return void 0;
+    return {
+      path: row.cwd,
+      base: row.base,
+      root: row.repo,
+      createdAt: row.createdAt,
+      incarnation: row.incarnation,
+      host: row.host
+    };
   }
   const wt = row.cwd === null ? void 0 : getWorktreeAt(db, row.cwd);
   if (wt === void 0 || wt.agent !== row.name) return void 0;
@@ -11731,7 +12183,8 @@ async function run(db, req, taskId, key, guard, keep = false) {
     name: req.spawn.name,
     nextFree: req.spawn.nextFree === true,
     text: req.text,
-    host: req.spawn.host
+    host: req.spawn.host,
+    root: req.spawn.root
   });
   const saved = getReceipt(db, taskId, key);
   const auto = guard !== void 0;
@@ -11790,6 +12243,10 @@ async function fresh(db, req, taskId, key, sha, reuse = false) {
   const rec = reuse ? resetReceipt(db, taskId, key, base) : reserveReceipt(db, { taskId, attemptKey: key, workstream: ws, ...base });
   return drive(db, req, taskId, key, rec, void 0, void 0);
 }
+function delegateSession(db, task, ws) {
+  if (getTask(db, task, ws)?.kind !== "delegate") return {};
+  return { piSessionDir: delegateSessionDir(db.name, ws, task) };
+}
 async function drive(db, req, taskId, key, start, resumed, guard, keep = false) {
   const ws = req.spawn.workstream;
   if (resumed === void 0) guard?.("spawn");
@@ -11826,6 +12283,7 @@ async function drive(db, req, taskId, key, start, resumed, guard, keep = false)
       spawnThrew = true;
       const spawned = await spawnAgent3(db, {
         ...req.spawn,
+        ...delegateSession(db, req.task, ws),
         onIdentity: (r) => {
           rec = updateReceipt(db, taskId, key, {
             state: "pane",
@@ -11865,25 +12323,25 @@ async function drive(db, req, taskId, key, start, resumed, guard, keep = false)
     }
     req.spawn.signal?.throwIfAborted();
     const checked = db.transaction(() => {
-      const now = getAgentForCleanup(db, target.name, ws);
-      if (now === void 0 || now.incarnation !== target.incarnation || now.paneId !== target.paneId) {
+      const now2 = getAgentForCleanup(db, target.name, ws);
+      if (now2 === void 0 || now2.incarnation !== target.incarnation || now2.paneId !== target.paneId) {
         throw new AgentReplacedError(target.name, ws, "sent to");
       }
       guard?.("send");
       const t = getTask(db, req.task, ws);
       if (t === void 0) throw new TaskNotFoundError(req.task, ws);
       if (t.status === "CLOSED") throw new SpawnTaskStateError(req.task, "was closed");
-      if (t.ownerId !== now.incarnation) {
+      if (t.ownerId !== now2.incarnation) {
         if (t.ownerId !== null) {
           throw new TaskAlreadyOwnedError(req.task, t.ownerName ?? "<unknown>");
         }
-        throw new SpawnTaskStateError(req.task, `is no longer claimed by ${now.name}`);
+        throw new SpawnTaskStateError(req.task, `is no longer claimed by ${now2.name}`);
       }
       const journaled = updateReceipt(db, taskId, key, {
         state: "sending",
-        transport: expectsCtl(now, agentCtlSocket(db, now)) ? "ctl" : "mux"
+        transport: expectsCtl(now2, agentCtlSocket(db, now2)) ? "ctl" : "mux"
       });
-      return { row: now, rec: journaled };
+      return { row: now2, rec: journaled };
     }).immediate();
     row = checked.row;
     rec = checked.rec;
@@ -11995,13 +12453,13 @@ function idleThresholdMs() {
   if (!Number.isFinite(n) || n < 0) return DEFAULT_IDLE_THRESHOLD_MS;
   return n;
 }
-function computeAgentIdle(db, agent, now = Date.now()) {
+function computeAgentIdle(db, agent, now2 = Date.now()) {
   if (agent.state !== "needs_input" || agent.since === null) return false;
   const threshold = idleThresholdMs();
   if (threshold <= 0) return false;
   const since = Date.parse(agent.since);
   if (!Number.isFinite(since)) return false;
-  if (now - since < threshold) return false;
+  if (now2 - since < threshold) return false;
   if (isScratchWorkstream(agent.workstreamName)) return true;
   const wsId = tryResolveWorkstreamId(db, agent.workstreamName);
   if (wsId === null) return false;
@@ -12028,6 +12486,7 @@ var SELECT_AGENT_COLS = `
   a.spawner AS spawner,
   a.host AS host,
   a.collected_head AS collected_head,
+  a.repo AS repo,
   a.gate_token AS gate_token,
   a.created_at AS created_at,
   a.updated_at AS updated_at
@@ -12049,6 +12508,7 @@ function rowFromDb3(row) {
     spawner: row.spawner,
     host: row.host,
     collectedHead: row.collected_head,
+    repo: row.repo,
     gateToken: row.gate_token,
     createdAt: row.created_at,
     updatedAt: row.updated_at
@@ -12064,13 +12524,13 @@ function agentIdByName(db, name, workstream) {
 function insertAgent(db, input) {
   ensureWorkstream(db, input.workstream);
   const workstreamId = resolveWorkstreamId(db, input.workstream);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
   try {
     db.prepare(
-      `INSERT INTO agents (name, workstream_id, cli, pane_id, status, role, tab, cwd, base, command, command_source, spawner, host, collected_head, gate_token, created_at, updated_at)
+      `INSERT INTO agents (name, workstream_id, cli, pane_id, status, role, tab, cwd, base, command, command_source, spawner, host, collected_head, repo, gate_token, created_at, updated_at)
        VALUES (@name, @workstreamId, COALESCE(@cli, 'pi'), @paneId, 'spawning',
                COALESCE(@role, 'full-access'), @tab, @cwd, @base, @command, @commandSource,
-               @spawner, @host, @collectedHead, @gateToken, @now, @now)`
+               @spawner, @host, @collectedHead, @repo, @gateToken, @now, @now)`
     ).run({
       name: input.name,
       workstreamId,
@@ -12085,8 +12545,9 @@ function insertAgent(db, input) {
       spawner: input.spawner ?? null,
       host: input.host ?? null,
       collectedHead: input.collectedHead ?? null,
+      repo: input.repo ?? null,
       gateToken: input.gateToken ?? null,
-      now
+      now: now2
     });
   } catch (err) {
     if (err.code === "SQLITE_CONSTRAINT_UNIQUE") {
@@ -12207,7 +12668,7 @@ async function readLiveAgents(db, workstream, only, states) {
   const baseAgents = listAgents(db, { workstream }).filter(
     (a) => only === void 0 || a.name === only
   );
-  const stateDir = dirname10(db.name);
+  const stateDir = dirname11(db.name);
   let readings;
   if (states === void 0) readings = await readAgentStates(baseAgents, { stateDir });
   else {
@@ -12217,7 +12678,7 @@ async function readLiveAgents(db, workstream, only, states) {
     }
     readings = states.cache;
   }
-  const now = Date.now();
+  const now2 = Date.now();
   return baseAgents.map((agent) => {
     const reading = readings.get(agentKey(agent)) ?? {
       state: "unknown",
@@ -12235,14 +12696,14 @@ async function readLiveAgents(db, workstream, only, states) {
       ...reading.reason !== void 0 ? { reason: reading.reason } : {},
       ...reading.tool !== void 0 ? { tool: reading.tool } : {}
     };
-    return computeAgentIdle(db, live2, now) ? { ...live2, idle: true } : live2;
+    return computeAgentIdle(db, live2, now2) ? { ...live2, idle: true } : live2;
   });
 }
 
 // src/agents/spawn-lock.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function lockPathForSession(session) {
-  return join8(locksDir(), `spawn-${session}.lock`);
+  return join9(locksDir(), `spawn-${session}.lock`);
 }
 var DEFAULT_ACQUIRE_TIMEOUT_MS2 = 15e3;
 var STALE_LOCK_MS = 3e4;
@@ -12257,11 +12718,11 @@ async function withSpawnLock(session, fn, opts) {
 
 // src/agents/staging.ts
 var STAGING_DEAD_MS = 6e4;
-function deadStagings(db, workstream, now = Date.now()) {
+function deadStagings(db, workstream, now2 = Date.now()) {
   return listAgents(db, workstream === void 0 ? {} : { workstream }).filter((a) => {
     if (!isPendingPaneId(a.paneId) || a.host !== null) return false;
     const made = a.cwd === null ? void 0 : getWorktreeAt(db, a.cwd)?.createdAt;
-    return now - Math.max(Date.parse(a.updatedAt), made ? Date.parse(made) : 0) > STAGING_DEAD_MS;
+    return now2 - Math.max(Date.parse(a.updatedAt), made ? Date.parse(made) : 0) > STAGING_DEAD_MS;
   });
 }
 async function reclaimDeadStagings(db, workstream) {
@@ -12451,7 +12912,7 @@ async function spawnAgent3(db, opts) {
   const gateToken = isCommandGate(opts) ? newGateToken() : void 0;
   if (gateToken !== void 0 && opts.worktree) {
     throw new HostProfileError(
-      "--worktree cannot be used with a remote command gate (--host with a non-pi --command): a gate runs in the profile's repo or --cwd"
+      "--worktree cannot be used with a remote command gate (--host with a non-pi --command): a gate runs in --cwd, else the profile's default repo"
     );
   }
   const command = opts.command ?? (profile ? cli : resolved.command);
@@ -12480,7 +12941,8 @@ async function spawnAgent3(db, opts) {
           workstream: opts.workstream,
           name: opts.name,
           worktree: false,
-          ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {}
+          ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+          ...remoteRoot(opts, profile)
         });
     } else if (opts.worktree) {
       staged = await prestageWorktree(db, opts, cli, spawner);
@@ -12491,8 +12953,8 @@ async function spawnAgent3(db, opts) {
     throw err;
   }
   const paneCwd = staged?.path ?? site?.cwd ?? resolve3(opts.cwd ?? process.cwd());
-  const ctlSocket = ctlSocketPath(opts.workstream, opts.name, dirname11(db.name));
-  mkdirSync3(dirname11(ctlSocket), { recursive: true, mode: 448 });
+  const ctlSocket = ctlSocketPath(opts.workstream, opts.name, dirname12(db.name));
+  mkdirSync3(dirname12(ctlSocket), { recursive: true, mode: 448 });
   const paneEnv = profile ? {} : {
     MU_MANAGED_AGENT: "1",
     MU_AGENT_NAME: opts.name,
@@ -12501,6 +12963,9 @@ async function spawnAgent3(db, opts) {
     MU_DB_PATH: resolve3(db.name !== "" && db.name !== ":memory:" ? db.name : defaultDbPath()),
     MU_STATE_DIR: resolve3(defaultStateDir())
   };
+  if (!profile && opts.piSessionDir !== void 0 && speaksMuCtl(cli, command)) {
+    paneEnv.PI_CODING_AGENT_SESSION_DIR = resolve3(opts.piSessionDir);
+  }
   const sshSock = process.env.SSH_AUTH_SOCK;
   if (sshSock) {
     try {
@@ -12720,12 +13185,16 @@ async function prestageLocked(db, opts, cli, spawner) {
     throw err;
   }
 }
+function remoteRoot(opts, profile) {
+  const root = opts.root ?? profile.repo ?? void 0;
+  return root === void 0 ? {} : { root };
+}
 async function requireHostSpawn(db, opts) {
   const host = opts.host ?? "";
   const profile = getHost(db, host);
-  if (opts.root !== void 0) {
+  if (opts.worktree && opts.root === void 0 && profile.repo === null) {
     throw new HostProfileError(
-      "--root names a local repo and cannot be used with --host (the worktree is made in the profile's --repo)"
+      `host ${host} has no default repo: pass --root <remote repo path> with --worktree`
     );
   }
   const mux = await activeMux();
@@ -12751,6 +13220,7 @@ async function prestageRemote(db, opts, cli, spawner, lease, profile) {
         name: opts.name,
         worktree: true,
         ...opts.from !== void 0 ? { from: opts.from } : {},
+        ...remoteRoot(opts, profile),
         // An unused leftover of a prepare whose answer was lost is taken over;
         // never while a removed agent's recovery record may name that tree.
         reclaim: !recoveriesFor(db, opts.workstream, opts.name).some(
@@ -12760,7 +13230,7 @@ async function prestageRemote(db, opts, cli, spawner, lease, profile) {
       return {
         path: made.cwd,
         base: made.base ?? "",
-        root: profile.repo,
+        root: made.repo ?? "",
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         incarnation: placeholder.incarnation,
         host: profile.name
@@ -12799,7 +13269,7 @@ function finalizeAgentRow(db, args) {
     });
   }
   const patched = db.prepare(
-    `UPDATE agents SET pane_id = ?, cwd = ?, base = ?, command = ?, command_source = ?, spawner = ?, host = ?, updated_at = ?
+    `UPDATE agents SET pane_id = ?, cwd = ?, base = ?, command = ?, command_source = ?, spawner = ?, host = ?, repo = ?, updated_at = ?
       WHERE id = ? AND pane_id = ?
         AND name = ?
         AND workstream_id = (SELECT id FROM workstreams WHERE name = ?)`
@@ -12811,6 +13281,7 @@ function finalizeAgentRow(db, args) {
     commandSource,
     spawner,
     host ?? null,
+    staged.host !== void 0 ? staged.root : null,
     (/* @__PURE__ */ new Date()).toISOString(),
     staged.incarnation,
     pendingPaneIdFor(opts.name),
@@ -13688,6 +14159,22 @@ export {
   observeAgentStates,
   settledCloseInput,
   watchAgentRun,
+  verdictLineLabel,
+  parseVerdict,
+  delegateSessionDir,
+  delegateProcessDir,
+  TERMINAL_DELEGATE_STATES,
+  DelegateCallConflictError,
+  DelegateStateError,
+  DelegateNotFoundError,
+  getDelegateCall,
+  listDelegates,
+  listDelegatesOf,
+  registerDelegateCall,
+  markDelegate,
+  finishDelegate,
+  verdictTally,
+  tallyCalls,
   requestSha,
   getReceipt,
   reserveReceipt,
@@ -13763,4 +14250,4 @@ export {
   murmurAvailable,
   readAgentStates
 };
-//# sourceMappingURL=chunk-S424D5EP.js.map
+//# sourceMappingURL=chunk-UCZPJX7K.js.map