@mu-crew/mu 4.1.1 → 4.2.1

package/dist/{chunk-L7I3BLXP.js → chunk-4ZWBLTZK.js}

@@ -2052,7 +2052,7 @@ Matched line: ${line}${scroll}`,
   "mux.none_found": (tried) => `no supported multiplexer found (tried: ${tried.join(", ")}); install tmux \u2265 3.0 (task, DAG and sql verbs work without one)`,
   "mux.tmux_failed": (args, exit, detail) => `tmux ${args.join(" ")} failed (exit ${exit}): ${detail}`,
   "mux.herdr_failed": (args, exit, detail) => `herdr ${args.join(" ")} failed (exit ${exit}): ${detail}`,
-  "mux.herdr_syntax": (args, firstLine3) => `herdr rejected the command line (exit 2) \u2014 this is a bug in mu, not a herdr outage. Ran: herdr ${args.join(" ")}. herdr said: ${firstLine3}`,
+  "mux.herdr_syntax": (args, firstLine4) => `herdr rejected the command line (exit 2) \u2014 this is a bug in mu, not a herdr outage. Ran: herdr ${args.join(" ")}. herdr said: ${firstLine4}`,
   "mux.herdr_unsupported_cli": (cli, detail) => `herdr does not recognise --cli ${cli} as an interactive agent kind, so it cannot classify that pane's status. herdr said: ${detail}`,
   "mux.herdr_command_override": (cli, what) => `${what} cannot be honoured on the herdr backend: 'herdr agent start --kind ${cli}' resolves the executable itself and has no override flag. mu refuses rather than starting a different binary than you asked for.`,
   "mux.herdr_group_close": (workspaceId, session, detail) => `herdr refused to close workspace ${workspaceId} (${session}): it has linked worktree workspaces, which mu did not create and will not close on your behalf. herdr said: ${detail}`,
@@ -2067,6 +2067,23 @@ Matched line: ${line}${scroll}`,
   "host.in_use": (host, holders) => `host ${host} still holds channels (${holders.join(", ")}): close those agents first`,
   "host.spawn_unsupported": (host, mux) => `--host ${host} needs a multiplexer that runs a shell command in its pane; ${mux} starts agents itself and cannot run the profile's shell template (use tmux)`,
   "host.check_failed": (host, failed) => `host ${host} check failed: ${failed.join(", ")}`,
+  "host.handback": (host, field, detail) => `host ${host}: its ${field} template exited 3, a hand-back (a human must act, e.g. a hardware key)${detail === "" ? "" : `: ${detail}`}. Do not retry or ssh yourself: stop and ask`,
+  "carrier.stop_refused": (host, handle, why) => why === "stop-changed" ? `host ${host}: the stop template changed since job ${handle} was recorded; stop it by hand with the old template, or mu agent close <name> --abandon-job` : why === "no-host" ? `host ${host} has no profile; job ${handle} was not stopped: stop it by hand, or mu agent close <name> --abandon-job` : `job handle ${JSON.stringify(handle)} on host ${host} is not a valid handle (A-Z a-z 0-9 . _ : @ -, 1 to 128 bytes); nothing was run`,
+  "carrier.stop_failed": (host, handle, detail) => `host ${host}: stopping job ${handle} failed${detail === "" ? "" : `: ${detail}`}; its handle is kept`,
+  "carrier.job_unstopped": (name, handle, host, reason = null) => reason === null ? `${name} has an unstopped job ${handle} on ${host}: mu agent close ${name}` : `${name} has job ${handle} on ${host} kept with its reservation (${reason}): mu agent close ${name}`,
+  "carrier.job_reserved": (name, host, launch, pane, reason = null) => launch === "none" ? reason !== null ? `${name} is reserved by a lease spawn on ${host} that failed before launching its carrier and kept the reservation as the only pointer to what it left: ${reason}. Remove that on the host if it is still there, then drop the reservation: mu agent close ${name} --abandon-job` : `${name} is reserved by a lease spawn on ${host} that has not launched its carrier (in progress, or its spawn was killed): mu agent close ${name}` : `${name} is reserved by a lease spawn on ${host} whose carrier may have been launched (pane ${pane ?? "unknown"}) and whose job handle is unknown${reason === null ? "" : ` (${reason})`}: mu agent close ${name}, or mu agent close ${name} --abandon-job once that job is dealt with`,
+  "carrier.job_unresolved": (name, ws, host, facts, keptForTree) => keptForTree ? `${name}: its lease spawn on ${host} failed before launching a carrier and kept the reservation for what it left (${facts}); nothing was closed. Remove that on the host if it is still there, then: mu agent close ${name} -w ${ws} --abandon-job` : `${name}: spawn in progress, or its lease carrier on ${host} may still publish a job handle (${facts}); nothing was closed. Retry once the spawn settles; once that job is dealt with: mu agent close ${name} -w ${ws} --abandon-job`,
+  "carrier.job_kept": (name, ws, host, why) => `${name}: ${why}; its reservation on ${host} is kept: check that job, then mu agent close ${name} -w ${ws} again, or --abandon-job`,
+  "carrier.job_unreadable": (name, file, detail) => `agent ${name}: the job file ${file} exists but cannot be read (${detail}); rolled back, its reservation and any remote worktree kept`,
+  "carrier.rollback_reserved": (name, ws, host, why) => `the lease spawn's carrier on ${host} may have dispatched a job (${why}): the reservation and any remote worktree are kept; mu agent close ${name} -w ${ws}, or --abandon-job once that job is dealt with`,
+  "carrier.reservation_abandoned": (name, host, file, facts) => `agent close ${name} --abandon-job: reservation on ${host} dropped without a stop (${facts}); a late job handle would be in ${file}, left in place`,
+  "carrier.lease_gate": (host) => `host ${host} is a lease profile, which runs no command gates (a carrier's exit is not a gate result): use a session profile, or run the command through the carrier directly`,
+  "carrier.job_timeout": (name, host, ms, file) => `agent ${name} on ${host}: its carrier wrote no job handle to ${file} within ${ms}ms (MU_SPAWN_JOB_MS); rolled back. Does the profile's shell pass {job_file} to the carrier?`,
+  "carrier.job_invalid": (name, file, line) => `agent ${name}: the job file ${file} holds ${JSON.stringify(line.slice(0, 80))}, not a handle (A-Z a-z 0-9 . _ : @ -, 1 to 128 bytes); rolled back, its reservation and any remote worktree kept`,
+  "carrier.job_unrecorded": (name, handle) => `agent ${name}: job ${handle} could not be recorded (the spawn's reservation was abandoned or holds another handle); rolled back, nothing stopped`,
+  "carrier.transport_changed": (host) => `host ${host}: its transport changed while the spawn was admitted; nothing was launched, try again`,
+  "carrier.rollback_kept": (name, ws, host, handle, why) => `job ${handle} on ${host} was not stopped (${why}): its handle and any remote worktree are kept; once the host answers: mu agent close ${name} -w ${ws}`,
+  "carrier.dead_worker": (name, host, handle) => handle === null ? `remote worker ${name} on ${host} has no pane, and its carrier may have dispatched a job whose handle is unknown: mu agent close ${name} (mu agent collect first keeps its commits)` : `remote worker ${name} on ${host} has no pane, but its job ${handle} may still run there: mu agent close ${name} stops it (mu agent collect first keeps its commits)`,
   "host.channel_lost": (host, holder) => `host ${host}: channel ${holder} was lost`,
   "remote.prepare": (host, what, detail) => `host ${host}: ${what}${detail === "" ? "" : `: ${detail}`}`,
   "remote.worktree_kept": (agent, detail) => `agent ${agent}: remote worktree kept: ${detail}`,
@@ -2096,13 +2113,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 dirname12, resolve as resolve3 } from "path";
-import { setTimeout as delay } from "timers/promises";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, rmSync as rmSync4, statSync as statSync2 } from "fs";
+import { basename as basename2, dirname as dirname13, resolve as resolve3 } from "path";
 import { promisify as promisify3 } from "util";
 
 // src/agents.ts
-import { dirname as dirname11 } from "path";
+import { dirname as dirname12 } from "path";
 
 // src/agent-state.ts
 import { accessSync, constants, existsSync as existsSync2 } from "fs";
@@ -2783,6 +2799,53 @@ function captureDoctorCheck(db, sqliteVersion) {
   return { status: "ok", detail: `capture ${stamp}, triggers ${short}, sqlite ${version}` };
 }
 
+// src/db-carrier.ts
+var CARRIER_JOBS_DDL = `
+-- carrier_jobs: the RESERVATION of a lease agent's remote job (machine-local).
+-- Inserted before the carrier's pane opens, name-exclusive per (workstream, name)
+-- (ordinal 0; a rebuilt pre-reservation table's older rows of one name get 1..n),
+-- every update guarded by the immutable spawn token. 'launch' turns 'intent' just
+-- before the mux is asked for the pane; agent_id binds at finalize, job at the
+-- handshake. No FK, no trigger, no op: agent deletion never touches it. Released
+-- (deleted) only after a successful stop and the job file's and tree's cleanup, by
+-- its creator when nothing was launched, or by an explicit abandon. 'host_stop' is
+-- the admitted stop template. 'tree_path'/'tree_agent_id': the remote worktree a
+-- --worktree spawn prepared for it (path on 'host', and the placeholder incarnation a
+-- recovery record would carry); a close with no agent row releases the reservation
+-- only once THAT tree's close succeeded.
+CREATE TABLE IF NOT EXISTS carrier_jobs (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  token         TEXT NOT NULL UNIQUE,
+  workstream    TEXT NOT NULL,
+  name          TEXT NOT NULL,
+  ordinal       INTEGER NOT NULL DEFAULT 0,
+  host          TEXT NOT NULL,
+  host_stop     TEXT NOT NULL,
+  launch        TEXT NOT NULL DEFAULT 'none' CHECK (launch IN ('none', 'intent')),
+  creator_pid   INTEGER,
+  creator_start TEXT,
+  agent_id      INTEGER,
+  pane_id       TEXT,
+  job           TEXT,
+  reason        TEXT,
+  created_at    TEXT NOT NULL,
+  recorded_at   TEXT,
+  tree_path     TEXT,
+  tree_agent_id INTEGER
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_carrier_jobs_name ON carrier_jobs (workstream, name, ordinal);
+`;
+function carrierJobsPreReservation(db) {
+  return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'carrier_jobs'").get() !== void 0 && db.prepare("SELECT 1 FROM pragma_table_info('carrier_jobs') WHERE name = 'token'").get() === void 0;
+}
+var CARRIER_JOBS_REBUILD = `INSERT INTO carrier_jobs
+  (token, workstream, name, ordinal, host, host_stop, launch, agent_id, job, created_at, recorded_at)
+  SELECT lower(hex(randomblob(16))), COALESCE(workstream, ''), COALESCE(name, ''),
+         ROW_NUMBER() OVER (PARTITION BY workstream, name ORDER BY agent_id DESC) - 1,
+         COALESCE(host, ''), host_stop, 'intent', agent_id, job,
+         COALESCE(recorded_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')), recorded_at
+  FROM carrier_jobs_pre_reservation ORDER BY agent_id`;
+
 // src/db-recovery.ts
 var REASON = `CASE COALESCE((SELECT intent FROM op_ctx WHERE id = 1), '')
          WHEN 'workstream.teardown' THEN 'teardown'
@@ -3104,7 +3167,13 @@ function hostProfilesRepoRequired(db) {
 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}`);
+  const oldCarrierJobs = carrierJobsPreReservation(db);
+  if (oldCarrierJobs) db.exec("ALTER TABLE carrier_jobs RENAME TO carrier_jobs_pre_reservation");
   db.exec(CURRENT_SCHEMA);
+  if (oldCarrierJobs) {
+    db.exec(CARRIER_JOBS_REBUILD);
+    db.exec("DROP TABLE carrier_jobs_pre_reservation");
+  }
   for (const [table, column, ddl] of ADDED_COLUMNS) {
     if (!hasColumn(db, table, column)) db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
   }
@@ -3182,7 +3251,17 @@ var ADDED_COLUMNS = [
   ...["request", "verdict", "agent"].map((c) => ["delegate_calls", c, "TEXT"]),
   // The template's process group, recorded before it runs (hosts.ts).
   ["host_channels", "pgid", "INTEGER"],
-  ["host_channels", "pgid_start", "TEXT"]
+  ["host_channels", "pgid_start", "TEXT"],
+  // A host profile's transport ('session' | 'lease', validated in addHost: SQLite adds no CHECK
+  // in place) and a lease profile's stop template (hosts.ts).
+  ["host_profiles", "transport", "TEXT NOT NULL DEFAULT 'session'"],
+  ["host_profiles", "stop", "TEXT"],
+  // The transport of the profile a remote agent was spawned on ('session' | 'lease'): a close
+  // decides lease-ness from the row, never from the profile as it is now.
+  ["agents", "host_transport", "TEXT"],
+  // A lease reservation's remote worktree (src/carrier-jobs.ts): which tree it belongs to.
+  ["carrier_jobs", "tree_path", "TEXT"],
+  ["carrier_jobs", "tree_agent_id", "INTEGER"]
 ];
 function hasColumn(db, table, column) {
   return db.prepare("SELECT 1 AS x FROM pragma_table_info(?) WHERE name = ?").get(table, column) !== void 0;
@@ -3196,6 +3275,7 @@ function schemaIsCurrent(db) {
   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 (carrierJobsPreReservation(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;
@@ -3213,6 +3293,7 @@ var DEFAULT_EFFORT_DAYS = 1;
 var EXPECTED_TABLES = [
   "agent_settles",
   "agents",
+  "carrier_jobs",
   "delegate_calls",
   "host_channels",
   "host_profiles",
@@ -3244,6 +3325,7 @@ var PORTABLE_TABLES = ["task_edges", "task_notes", "tasks", "workstreams"];
 var MACHINE_LOCAL_TABLES = [
   "agent_settles",
   "agents",
+  "carrier_jobs",
   "delegate_calls",
   "host_channels",
   "host_profiles",
@@ -3416,6 +3498,7 @@ CREATE TABLE IF NOT EXISTS agents (
   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
+  host_transport TEXT,                          -- the transport of the profile it was spawned on, 'session' | 'lease' (machine-local); NULL: local, or a row older than the column
   created_at    TEXT NOT NULL,
   updated_at    TEXT NOT NULL,
   UNIQUE (workstream_id, name),
@@ -3661,9 +3744,12 @@ CREATE TABLE IF NOT EXISTS host_profiles (
   exec         TEXT NOT NULL,
   fetch        TEXT NOT NULL,
   repo         TEXT,                           -- default remote repo for spawns without --root; NULL: none
-  max_sessions INTEGER CHECK (max_sessions > 0)
+  max_sessions INTEGER CHECK (max_sessions > 0),
+  transport    TEXT NOT NULL DEFAULT 'session', -- 'session' | 'lease' (validated in addHost, no CHECK: ADDED_COLUMNS cannot add one)
+  stop         TEXT                            -- lease only: the template that ends a job given its handle ({job}); NULL for session
 );
 
+${CARRIER_JOBS_DDL}
 -- host_channels: the connection slots of a host (machine-local). One row
 -- per holder. 'transient' rides an invocation (exec, fetch, check) and is
 -- reclaimed only when its pid is proven gone; 'attached' rides an agent's
@@ -3801,17 +3887,23 @@ ${GOALS_VIEW_SQL}
 // src/ctl/path.ts
 var CTL_SOCK_ENV = "MU_CTL_SOCK";
 var MAX_SOCK_PATH = 103;
-function sockPathUnder(dir, workstream, agent) {
-  const readable = join2(dir, workstream, `${agent}.sock`);
+var HASHED_DIR = "_h";
+function sockPathUnder(dir, workstream, agent, ext = "sock") {
+  const readable = join2(dir, workstream, `${agent}.${ext}`);
   if (Buffer.byteLength(readable) <= MAX_SOCK_PATH) return readable;
   const h = createHash2("sha1").update(`${workstream}/${agent}`).digest("hex").slice(0, 16);
-  return join2(dir, "h", `${h}.sock`);
+  return join2(dir, HASHED_DIR, `${h}.${ext}`);
 }
 function ctlSocketPath(workstream, agent, stateDir) {
   const dbPath = process.env.MU_DB_PATH;
   const base = stateDir ?? (dbPath ? dirname2(dbPath) : defaultStateDir());
   return sockPathUnder(join2(base, "sock"), workstream, agent);
 }
+function carrierJobFilePath(workstream, agent, stateDir) {
+  const dbPath = process.env.MU_DB_PATH;
+  const base = stateDir ?? (dbPath ? dirname2(dbPath) : defaultStateDir());
+  return sockPathUnder(join2(base, "carrier"), workstream, agent, "job");
+}
 function unlinkCtlSocket(db, name, workstream) {
   if (db.memory) return;
   try {
@@ -3888,20 +3980,20 @@ function compareHlc(a, b) {
   if (a > b) return 1;
   return 0;
 }
-function nextHlc(db, now2 = Date.now()) {
+function nextHlc(db, now3 = 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(now2) });
+  ).get({ now: Math.floor(now3) });
   if (!row) throw new MachineIdentityMissingError();
   return formatHlc({ wallMs: row.last_wall, counter: row.last_counter, machineId: row.machine_id });
 }
-function receiveHlc(db, remoteHlc, now2 = Date.now()) {
+function receiveHlc(db, remoteHlc, now3 = Date.now()) {
   const remote = parseHlc(remoteHlc);
-  const wallNow = Math.floor(now2);
+  const wallNow = Math.floor(now3);
   const read = prepareCached(
     db,
     "SELECT machine_id, last_wall, last_counter FROM machine_identity WHERE id = 1"
@@ -6222,8 +6314,8 @@ function mapMurmurState(token, since) {
 function parseSince(value) {
   return value !== void 0 && /^\d+$/.test(value) ? Number(value) : null;
 }
-async function readMurmur(now2) {
-  if (murmurCache !== void 0 && now2 - murmurCache.at < MURMUR_CACHE_MS) {
+async function readMurmur(now3) {
+  if (murmurCache !== void 0 && now3 - murmurCache.at < MURMUR_CACHE_MS) {
     return murmurCache.stdout;
   }
   let stdout;
@@ -6232,7 +6324,7 @@ async function readMurmur(now2) {
   } catch {
     stdout = null;
   }
-  murmurCache = { at: now2, stdout };
+  murmurCache = { at: now3, stdout };
   return stdout;
 }
 function remotePanes(stdout) {
@@ -6443,9 +6535,117 @@ async function readBaseStates(agents, opts, livenessOnly = /* @__PURE__ */ new S
 }
 
 // src/hosts.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { readFileSync } from "fs";
 import { dirname as dirname4 } from "path";
+
+// src/carrier-jobs.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var toJob = (r) => ({
+  token: r.token,
+  workstream: r.workstream,
+  name: r.name,
+  host: r.host,
+  hostStop: r.host_stop,
+  launch: r.launch,
+  creatorPid: r.creator_pid,
+  creatorStart: r.creator_start,
+  agentId: r.agent_id,
+  paneId: r.pane_id,
+  job: r.job,
+  reason: r.reason,
+  treePath: r.tree_path,
+  treeAgentId: r.tree_agent_id,
+  createdAt: r.created_at,
+  recordedAt: r.recorded_at
+});
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+function reserveCarrierJob(db, a) {
+  const token = randomUUID4();
+  try {
+    const r = db.prepare(
+      `INSERT INTO carrier_jobs (token, workstream, name, host, host_stop, launch, creator_pid, creator_start, created_at)
+         SELECT ?, ?, ?, ?, ?, 'none', ?, ?, ?
+         WHERE NOT EXISTS (SELECT 1 FROM carrier_jobs WHERE workstream = ? AND name = ?)`
+    ).run(
+      token,
+      a.workstream,
+      a.name,
+      a.host,
+      a.hostStop,
+      a.creatorPid ?? null,
+      a.creatorStart ?? null,
+      now(),
+      a.workstream,
+      a.name
+    );
+    if (r.changes !== 1) return void 0;
+  } catch (err) {
+    if (err.code === "SQLITE_CONSTRAINT_UNIQUE") return void 0;
+    throw err;
+  }
+  return getCarrierJob(db, token);
+}
+function getCarrierJob(db, token) {
+  const r = db.prepare("SELECT * FROM carrier_jobs WHERE token = ?").get(token);
+  return r === void 0 ? void 0 : toJob(r);
+}
+function getCarrierJobByAgent(db, agentId) {
+  const r = db.prepare("SELECT * FROM carrier_jobs WHERE agent_id = ?").get(agentId);
+  return r === void 0 ? void 0 : toJob(r);
+}
+function getCarrierJobByName(db, workstream, name) {
+  return listCarrierJobsByName(db, workstream, name)[0];
+}
+function listCarrierJobsByName(db, workstream, name) {
+  return db.prepare(
+    "SELECT * FROM carrier_jobs WHERE workstream = ? AND name = ? ORDER BY ordinal, id DESC"
+  ).all(workstream, name).map(toJob);
+}
+function listCarrierJobs(db) {
+  return db.prepare("SELECT * FROM carrier_jobs ORDER BY id").all().map(toJob);
+}
+function setCarrierJobStop(db, token, hostStop) {
+  return db.prepare(
+    "UPDATE carrier_jobs SET host_stop = ? WHERE token = ? AND launch = 'none' AND job IS NULL"
+  ).run(hostStop, token).changes === 1;
+}
+function markCarrierLaunch(db, token) {
+  return db.prepare("UPDATE carrier_jobs SET launch = 'intent' WHERE token = ?").run(token).changes === 1;
+}
+function recordCarrierPane(db, token, paneId) {
+  return db.prepare(
+    "UPDATE carrier_jobs SET pane_id = ? WHERE token = ? AND (pane_id IS NULL OR pane_id = ?)"
+  ).run(paneId, token, paneId).changes === 1;
+}
+function bindCarrierJobAgent(db, token, agentId, paneId) {
+  return db.prepare(
+    `UPDATE carrier_jobs SET agent_id = ?, pane_id = ?
+         WHERE token = ? AND (agent_id IS NULL OR agent_id = ?) AND (pane_id IS NULL OR pane_id = ?)`
+  ).run(agentId, paneId, token, agentId, paneId).changes === 1;
+}
+function fillCarrierJob(db, token, job) {
+  db.prepare(
+    "UPDATE carrier_jobs SET job = ?, reason = NULL, recorded_at = ? WHERE token = ? AND job IS NULL"
+  ).run(job, now(), token);
+  return getCarrierJob(db, token)?.job === job;
+}
+function noteCarrierJob(db, token, reason) {
+  db.prepare("UPDATE carrier_jobs SET reason = ? WHERE token = ?").run(reason, token);
+}
+function keepCarrierJobForTree(db, token, tree) {
+  db.prepare(
+    "UPDATE carrier_jobs SET reason = ?, tree_path = ?, tree_agent_id = ? WHERE token = ?"
+  ).run(tree.reason, tree.path, tree.agentId, token);
+}
+function releaseCarrierJob(db, job) {
+  return db.prepare("DELETE FROM carrier_jobs WHERE token = ? AND job IS ?").run(job.token, job.job).changes === 1;
+}
+function abandonCarrierJob(db, job) {
+  return releaseCarrierJob(db, job);
+}
+
+// src/hosts.ts
 var HostProfileError = class extends Error {
   name = "HostProfileError";
 };
@@ -6498,6 +6698,19 @@ var HostSpawnUnsupportedError = class extends Error {
   mux;
   name = "HostSpawnUnsupportedError";
 };
+var HostHandbackError = class extends Error {
+  constructor(host, field, detail) {
+    super(say("host.handback", host, field, detail));
+    this.host = host;
+    this.field = field;
+    this.detail = detail;
+  }
+  host;
+  field;
+  detail;
+  name = "HostHandbackError";
+  handback = true;
+};
 var HostCheckFailedError = class extends Error {
   constructor(host, failed) {
     super(say("host.check_failed", host, failed));
@@ -6508,6 +6721,8 @@ var HostCheckFailedError = class extends Error {
   failed;
   name = "HostCheckFailedError";
 };
+var HOST_TRANSPORTS = ["session", "lease"];
+var JOB_HANDLE_RE = /^[A-Za-z0-9._:@-]{1,128}$/;
 var HOST_NAME_RE = /^[a-z][a-z0-9_-]{0,31}$/;
 function isValidHostName(name) {
   return HOST_NAME_RE.test(name);
@@ -6520,7 +6735,12 @@ function getHost(db, name) {
 function listHosts(db) {
   return db.prepare("SELECT * FROM host_profiles ORDER BY name").all();
 }
-function addHost(db, p) {
+function addHost(db, input) {
+  const p = {
+    ...input,
+    transport: input.transport ?? "session",
+    stop: input.stop ?? null
+  };
   if (!isValidHostName(p.name)) {
     throw new HostProfileError(
       `invalid host name ${JSON.stringify(p.name)}: lowercase letters, digits, - and _, starting with a letter (max 32)`
@@ -6532,17 +6752,26 @@ function addHost(db, p) {
   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]);
-    } catch (e) {
-      if (e instanceof HostTemplateError) throw new HostTemplateError(`--${f}: ${e.message}`);
-      throw e;
-    }
+  if (!HOST_TRANSPORTS.includes(p.transport)) {
+    throw new HostProfileError(
+      `invalid --transport ${JSON.stringify(p.transport)}: ${HOST_TRANSPORTS.join(" or ")}`
+    );
+  }
+  if (p.transport === "lease" && p.stop === null) {
+    throw new HostProfileError(
+      "--stop is required for --transport lease: the template that ends a job given its handle ({job})"
+    );
+  }
+  if (p.transport === "session" && p.stop !== null) {
+    throw new HostProfileError(
+      "--stop is only for --transport lease: a session has no job to stop"
+    );
   }
+  const problem = profileTemplateProblem(p);
+  if (problem !== void 0) throw new HostTemplateError(problem);
   try {
     db.prepare(
-      "INSERT INTO host_profiles (name, shell, exec, fetch, repo, max_sessions) VALUES (@name, @shell, @exec, @fetch, @repo, @max_sessions)"
+      "INSERT INTO host_profiles (name, shell, exec, fetch, repo, max_sessions, transport, stop) VALUES (@name, @shell, @exec, @fetch, @repo, @max_sessions, @transport, @stop)"
     ).run(p);
   } catch (e) {
     if (e.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
@@ -6563,13 +6792,53 @@ function removeHost(db, name) {
 function hostStarter(host) {
   const ssh = "ssh -o ControlMaster=no -o ControlPath=none";
   return {
-    // ControlMaster=no: a multiplexed ssh never binds the local end of the forward.
+    // ControlMaster=no ControlPath=none: a `-L` through a shared control master is bound by the
+    // master, not by this client. The listener outlives the pane, and a later ssh asking for
+    // the same forward exits 0 with no socket file (the master never re-binds it). Each pane
+    // keeps its own connection, so its forward dies with it.
     shell: `${ssh} -o StreamLocalBindUnlink=yes -o ExitOnForwardFailure=yes -L {local_sock}:{remote_sock} ${host} -t 'cd {cwd:sh} && {env} "$SHELL" -ilc {cmd:sh}'`,
     exec: `${ssh} -o BatchMode=yes ${host} {cmd}`,
     fetch: `git fetch ssh://${host}{cwd} HEAD`
   };
 }
-var HOST_PLACEHOLDERS = ["env", "cmd", "local_sock", "remote_sock", "cwd"];
+function hostMuleStarter(host) {
+  return {
+    shell: `mule run --host ${host} --lease --human --cwd {cwd} --job-file {job_file} --forward-unix {local_sock}:{remote_sock} -- env {env} sh -c {cmd}`,
+    exec: `mule exec --host ${host} -- sh -c {cmd}`,
+    fetch: `git fetch ssh://${host}{cwd} HEAD`,
+    stop: `mule rm --host ${host} {job}`
+  };
+}
+var HOST_PLACEHOLDERS = [
+  "env",
+  "cmd",
+  "local_sock",
+  "remote_sock",
+  "cwd",
+  "job_file",
+  "job"
+];
+var LEGACY_PLACEHOLDERS = [
+  "env",
+  "cmd",
+  "local_sock",
+  "remote_sock",
+  "cwd"
+];
+var TEMPLATE_SCOPES = {
+  shell: LEGACY_PLACEHOLDERS,
+  "lease-shell": [...LEGACY_PLACEHOLDERS, "job_file"],
+  exec: LEGACY_PLACEHOLDERS,
+  fetch: LEGACY_PLACEHOLDERS,
+  stop: ["job", "cwd"]
+};
+var SCOPE_LABEL = {
+  shell: "session shell",
+  "lease-shell": "lease shell",
+  exec: "exec",
+  fetch: "fetch",
+  stop: "stop"
+};
 var HOST_ENV_KEYS = [
   "MU_MANAGED_AGENT",
   "MU_AGENT_NAME",
@@ -6594,7 +6863,7 @@ function hostEnvWords(env) {
   return words.join(" ");
 }
 var KNOWN = `${HOST_PLACEHOLDERS.map((p) => `{${p}}`).join(" ")}; {name:sh} quotes for a second shell`;
-function parseTemplate(t) {
+function parseTemplate(t, scope) {
   const out = [];
   let lit = "";
   let ctx = "none";
@@ -6630,6 +6899,11 @@ function parseTemplate(t) {
           "{env:sh} is refused: {env} is already text for the inner shell"
         );
       }
+      if (scope !== void 0 && !TEMPLATE_SCOPES[scope].includes(name)) {
+        throw new HostTemplateError(
+          `{${name}} is not valid in the ${SCOPE_LABEL[scope]} template (it takes ${TEMPLATE_SCOPES[scope].map((p) => `{${p}}`).join(" ")})`
+        );
+      }
       if (ctx === "dq" && subst) {
         throw new HostTemplateError(`{${name}} inside $(...) or backticks in double quotes`);
       }
@@ -6668,12 +6942,44 @@ function parseTemplate(t) {
   flush();
   return out;
 }
-function validateHostTemplate(template) {
-  parseTemplate(template);
+function validateHostTemplate(template, scope) {
+  parseTemplate(template, scope);
+}
+function placeholderUses(template, scope) {
+  const n = Object.fromEntries(HOST_PLACEHOLDERS.map((p) => [p, 0]));
+  for (const tok of parseTemplate(template, scope)) if ("ph" in tok) n[tok.ph]++;
+  return n;
+}
+function leaseShellProblems(shell) {
+  const n = placeholderUses(shell, "lease-shell");
+  return [
+    ...n.job_file === 1 ? [] : [`a lease shell template must contain {job_file} exactly once (found ${n.job_file})`],
+    ...n.local_sock > 0 ? [] : ["a lease shell template must contain {local_sock}"],
+    ...n.remote_sock > 0 ? [] : ["a lease shell template must contain {remote_sock}"]
+  ];
+}
+function profileTemplateProblem(p) {
+  const fields = [
+    ["shell", p.shell, p.transport === "lease" ? "lease-shell" : "shell"],
+    ["exec", p.exec, "exec"],
+    ["fetch", p.fetch, "fetch"],
+    ...p.stop === null ? [] : [["stop", p.stop, "stop"]]
+  ];
+  for (const [f, t, scope] of fields) {
+    try {
+      validateHostTemplate(t, scope);
+      const extra = scope === "lease-shell" ? leaseShellProblems(t) : scope === "stop" && placeholderUses(t, scope).job === 0 ? ["a stop template must contain {job}"] : [];
+      if (extra.length > 0) return `--${f}: ${extra.join("; ")}`;
+    } catch (e) {
+      if (e instanceof HostTemplateError) return `--${f}: ${e.message}`;
+      throw e;
+    }
+  }
+  return void 0;
 }
-function expandHostTemplate(template, values) {
+function expandHostTemplate(template, values, scope) {
   let out = "";
-  for (const tok of parseTemplate(template)) {
+  for (const tok of parseTemplate(template, scope)) {
     if ("lit" in tok) {
       out += tok.lit;
       continue;
@@ -6722,8 +7028,8 @@ function pidProvenGone(pid, start) {
     return e.code === "ESRCH";
   }
   if (start === null) return false;
-  const now2 = pidStart(pid);
-  return now2 !== null && now2 !== start;
+  const now3 = pidStart(pid);
+  return now3 !== null && now3 !== start;
 }
 function groupAlive(pgid, start) {
   try {
@@ -6732,8 +7038,8 @@ function groupAlive(pgid, start) {
     return e.code !== "ESRCH";
   }
   if (start === null) return true;
-  const now2 = pidStart(pgid);
-  return now2 === null || now2 === start;
+  const now3 = pidStart(pgid);
+  return now3 === null || now3 === start;
 }
 async function probeAttached(db, host, paneAlive3) {
   if (paneAlive3 === void 0) return [];
@@ -6775,7 +7081,7 @@ async function admitHostChannel(db, host, holder, opts = {}) {
 async function admit(db, host, holder, opts) {
   getHost(db, host);
   const dead = await probeAttached(db, host, opts.paneAlive);
-  const token = randomUUID4();
+  const token = randomUUID5();
   const profile = db.transaction(() => {
     const profile2 = getHost(db, host);
     reclaim(db, host, dead);
@@ -6830,13 +7136,27 @@ async function withHostChannel(db, host, holder, run2, opts = {}) {
   }
 }
 var HOST_COMMAND_TIMEOUT_MS = 2e4;
+var HOST_GRACE_MS = 5e3;
 async function runLeasedTemplate(db, lease, profile, field, values, timeoutMs, localCwd) {
-  const expanded = expandHostTemplate(profile[field], values);
-  return execGroupCapture("/bin/sh", ["-c", expanded], {
+  const template = profile[field];
+  if (template === null)
+    throw new HostTemplateError(`host ${profile.name} has no ${field} template`);
+  const expanded = expandHostTemplate(template, values, field);
+  const run2 = await execGroupCapture("/bin/sh", ["-c", expanded], {
     timeoutMs,
+    // A carrier interrupted by the timeout needs time to stop what it dispatched.
+    graceMs: HOST_GRACE_MS,
     ...localCwd !== void 0 ? { cwd: localCwd } : {},
     onSpawn: (pgid) => recordGroup(db, lease, pgid)
   });
+  if (run2.exitCode === 3) {
+    throw new HostHandbackError(
+      profile.name,
+      field,
+      firstLine(run2.stderr) || firstLine(run2.stdout)
+    );
+  }
+  return run2;
 }
 async function runHostTemplate(db, host, field, holder, values, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? HOST_COMMAND_TIMEOUT_MS;
@@ -6854,14 +7174,22 @@ async function checkHost(db, host, opts = {}) {
   getHost(db, host);
   const timeoutMs = opts.timeoutMs ?? HOST_COMMAND_TIMEOUT_MS;
   const steps = [];
-  const login = (cmd) => `"\${SHELL:-sh}" -ilc ${shellQuote(cmd)}`;
+  let warnings = [];
+  let handedBack = false;
   await withHostChannel(
     db,
     host,
     `check:${process.pid}`,
     async (profile, lease) => {
       const root = opts.root ?? profile.repo ?? void 0;
+      warnings = sessionShellWarnings(profile);
+      const login = (cmd) => profile.transport === "lease" ? cmd : `"\${SHELL:-sh}" -ilc ${shellQuote(cmd)}`;
+      if (profile.transport === "lease") steps.push(...leaseTemplateSteps(profile));
       const step = async (name, cmd, good, unmet) => {
+        if (handedBack) {
+          steps.push({ step: name, ok: null, detail: "skipped: the host handed back" });
+          return false;
+        }
         let detail;
         let ok = false;
         try {
@@ -6879,6 +7207,12 @@ async function checkHost(db, host, opts = {}) {
           ok = good1 !== void 0;
           detail = good1 ?? (r.exitCode === null ? `timed out after ${timeoutMs}ms` : r.exitCode === 0 ? unmet : `exit ${r.exitCode}${why === "" ? "" : `: ${why}`}`);
         } catch (e) {
+          if (e instanceof HostHandbackError) {
+            handedBack = true;
+            steps.push({ step: name, ok: null, detail: "skipped: the host handed back" });
+            steps.push({ step: "handback", ok: false, detail: `${name}: ${e.message}` });
+            return false;
+          }
           if (!(e instanceof HostTemplateError)) throw e;
           detail = e.message;
         }
@@ -6905,10 +7239,19 @@ async function checkHost(db, host, opts = {}) {
         );
       } else {
         for (const s of ["repo", "pi", "extension"]) {
-          steps.push({ step: s, ok: null, detail: "skipped: host not reachable" });
+          steps.push({
+            step: s,
+            ok: null,
+            detail: handedBack ? "skipped: the host handed back" : "skipped: host not reachable"
+          });
         }
       }
-      if (opts.agent !== void 0) {
+      if (opts.agent !== void 0 && profile.transport === "lease") {
+        steps.push(leaseJobStep(db, profile, opts.agent));
+      }
+      if (opts.agent !== void 0 && handedBack) {
+        steps.push({ step: "ctl", ok: null, detail: "skipped: the host handed back" });
+      } else if (opts.agent !== void 0) {
         const { name, workstream } = opts.agent;
         const p = await ctlProbe(
           ctlSocketPath(workstream, name, dirname4(db.name)),
@@ -6930,11 +7273,62 @@ async function checkHost(db, host, opts = {}) {
     },
     opts
   );
-  return { host, ok: steps.every((s) => s.ok !== false), steps };
+  return { host, ok: steps.every((s) => s.ok !== false), steps, warnings };
+}
+var DUMMY_JOB = "check-job";
+function leaseTemplateSteps(profile) {
+  const problems = (() => {
+    try {
+      return leaseShellProblems(profile.shell);
+    } catch (e) {
+      if (e instanceof HostTemplateError) return [e.message];
+      throw e;
+    }
+  })();
+  const shell = problems.length === 0 ? {
+    step: "shell",
+    ok: true,
+    detail: "lease shell has {job_file}, {local_sock} and {remote_sock}"
+  } : { step: "shell", ok: false, detail: problems.join("; ") };
+  let stop;
+  try {
+    if (profile.stop === null) throw new HostTemplateError("a lease profile has no stop template");
+    if (placeholderUses(profile.stop, "stop").job === 0) {
+      throw new HostTemplateError("a stop template must contain {job}");
+    }
+    const line = expandHostTemplate(profile.stop, { job: DUMMY_JOB, cwd: "." }, "stop");
+    stop = { step: "stop", ok: true, detail: `expands (not run) to: ${line}` };
+  } catch (e) {
+    if (!(e instanceof HostTemplateError)) throw e;
+    stop = { step: "stop", ok: false, detail: e.message };
+  }
+  return [shell, stop];
+}
+function leaseJobStep(db, profile, agent) {
+  const who = `${agent.workstream}/${agent.name}`;
+  const job = getCarrierJobByName(db, agent.workstream, agent.name);
+  if (job === void 0 || job.host !== profile.name || job.job === null) {
+    return { step: "job", ok: false, detail: `${who}: no job handle recorded on ${profile.name}` };
+  }
+  const drift = job.hostStop === profile.stop ? "" : "; the stop template changed since it was recorded: a close will refuse and name the handle";
+  return { step: "job", ok: true, detail: `${who}: job ${job.job}${drift}` };
+}
+function sessionShellWarnings(profile) {
+  if (profile.transport !== "session") return [];
+  const noMaster = /ControlMaster[= ]+no\b/i.test(profile.shell);
+  const noPath = /ControlPath[= ]+none\b/i.test(profile.shell);
+  if (noMaster && noPath) return [];
+  const lacks = [
+    ...noMaster ? [] : ["ControlMaster=no"],
+    ...noPath ? [] : ["ControlPath=none"]
+  ];
+  return [
+    `shell template lacks ${lacks.join(" and ")}: a forward that rides a shared ssh master is bound by the master and outlives the pane (heuristic; see mu host init --ssh)`
+  ];
 }
 
 // src/op-context.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var DEFAULT_CTX = { group_id: null, actor: null, intent: null, applying: 0 };
 function currentOpContext(db) {
   const row = readCtx(db) ?? DEFAULT_CTX;
@@ -7023,7 +7417,7 @@ function withOpContext(db, ctx, fn) {
   return withCtxRow(
     db,
     (previous) => {
-      const groupId = ctx.group === "new" ? randomUUID5() : ctx.group !== void 0 ? ctx.group : previous.group_id ?? randomUUID5();
+      const groupId = ctx.group === "new" ? randomUUID6() : ctx.group !== void 0 ? ctx.group : previous.group_id ?? randomUUID6();
       return {
         group_id: groupId,
         // An explicit undefined inherits; only a provided value overrides.
@@ -7058,15 +7452,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 now2 = (/* @__PURE__ */ new Date()).toISOString();
-    reopen.run(now2, t.taskId);
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    reopen.run(now3, 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`,
-        now2
+        now3
       )
     );
   }
@@ -7221,7 +7615,10 @@ function withTaskFence(db, workstream, id, expected, fn, previewCommand) {
   }).immediate();
 }
 function agentRevision(db, workstream, name, recoveryId) {
-  if (recoveryId !== void 0) return recoveryRevision(db, workstream, name, recoveryId);
+  const carrier = carrierJobsOf(db, workstream, name);
+  if (recoveryId !== void 0) {
+    return recoveryRevision(db, workstream, name, carrier, 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.repo, a.gate_token, a.created_at
@@ -7237,19 +7634,36 @@ function agentRevision(db, workstream, name, recoveryId) {
     `SELECT path, root, base, last_collected_head, created_at FROM worktrees
         WHERE workstream = ? AND agent = ? ORDER BY path`
   ).all(workstream, name);
-  if (agent === void 0 && worktrees.length === 0) return recoveryRevision(db, workstream, name);
-  const digest = createHash3("sha256").update(JSON.stringify([agent ?? null, owned, worktrees])).digest();
+  if (agent === void 0 && worktrees.length === 0) {
+    return recoveryRevision(db, workstream, name, carrier);
+  }
+  const state = [agent ?? null, owned, worktrees];
+  if (carrier.length > 0) state.push(carrier);
+  const digest = createHash3("sha256").update(JSON.stringify(state)).digest();
   return digest.readUIntBE(0, 6);
 }
-function recoveryRevision(db, workstream, name, recoveryId) {
+function carrierJobsOf(db, workstream, name) {
+  return db.prepare(
+    `SELECT token, host, host_stop, launch, agent_id, pane_id, job, reason FROM carrier_jobs
+        WHERE workstream = ? AND name = ? ORDER BY id`
+  ).all(workstream, name);
+}
+function recoveryRevision(db, workstream, name, carrier, recoveryId) {
   const rows = db.prepare(
     `SELECT * FROM remote_recovery WHERE workstream = ? AND name = ?${recoveryId === void 0 ? "" : " AND agent_id = ?"} ORDER BY agent_id`
   ).all(...recoveryId === void 0 ? [workstream, name] : [workstream, name, recoveryId]);
-  if (rows.length === 0) return 0;
+  if (rows.length === 0) {
+    if (carrier.length === 0 || recoveryId !== void 0) return 0;
+    return createHash3("sha256").update(JSON.stringify(["lease-job", carrier])).digest().readUIntBE(0, 6);
+  }
   const live2 = db.prepare(
     "SELECT a.id FROM agents a JOIN workstreams w ON w.id = a.workstream_id WHERE w.name = ? AND a.name = ?"
   ).get(workstream, name);
-  const digest = createHash3("sha256").update(JSON.stringify(["recovery", rows, live2?.id ?? null])).digest();
+  const digest = createHash3("sha256").update(
+    JSON.stringify(
+      carrier.length > 0 ? ["recovery", rows, live2?.id ?? null, carrier] : ["recovery", rows, live2?.id ?? null]
+    )
+  ).digest();
   return digest.readUIntBE(0, 6);
 }
 
@@ -7531,8 +7945,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, now2) {
-  const ts = now2 ?? (/* @__PURE__ */ new Date()).toISOString();
+function touchTask(db, taskId, now3) {
+  const ts = now3 ?? (/* @__PURE__ */ new Date()).toISOString();
   db.prepare("UPDATE tasks SET updated_at = ? WHERE id = ? AND updated_at < ?").run(ts, taskId, ts);
 }
 
@@ -7918,13 +8332,13 @@ function addBlockEdgeImpl(db, workstream, blocked, blocker) {
   if (wouldCreateCycle(db, blockerId, blockedId)) {
     throw cycleErrorFor(db, blocker, blocked, blockerId, blockedId, blockedRow.workstreamName);
   }
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__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, now2, blockerId, blockedId);
+    ).run(blockerId, blockedId, now3, blockerId, blockedId);
     if (result.changes > 0) {
-      touchTask(db, blockedId, now2);
+      touchTask(db, blockedId, now3);
       return true;
     }
     return false;
@@ -8010,11 +8424,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 now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
     for (const blockerId of blockerIds) {
-      insertEdge.run(blockerId, taskSurrogateId, now2);
+      insertEdge.run(blockerId, taskSurrogateId, now3);
     }
-    touchTask(db, taskSurrogateId, now2);
+    touchTask(db, taskSurrogateId, now3);
     return { removedEdges: removed.changes, addedEdges: blockerIds.length };
   }).immediate();
 }
@@ -8926,9 +9340,9 @@ async function teardownWorkstream(db, opts) {
     db,
     { intent: "workstream.teardown", group: "new" },
     () => db.transaction(() => {
-      const now2 = workstreamRevision(db, opts.workstream);
-      if (now2 !== opts.ifRevision) {
-        throw new WorkstreamRevisionMismatchError(opts.workstream, opts.ifRevision, now2);
+      const now3 = workstreamRevision(db, opts.workstream);
+      if (now3 !== opts.ifRevision) {
+        throw new WorkstreamRevisionMismatchError(opts.workstream, opts.ifRevision, now3);
       }
       for (const a of dead) {
         if (!sameRow2.get(a.incarnation, a.name, a.paneId, opts.workstream)) continue;
@@ -9137,7 +9551,7 @@ function addTaskImpl(db, opts) {
     if (existing) {
       throw new TaskExistsError(opts.localId);
     }
-    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const now3 = (/* @__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', ?, ?, ?, ?, ?, ?, ?, ?)`
@@ -9151,8 +9565,8 @@ function addTaskImpl(db, opts) {
       opts.impact ?? DEFAULT_IMPACT,
       opts.effortDays ?? DEFAULT_EFFORT_DAYS,
       opts.impact !== void 0 || opts.effortDays !== void 0 ? 1 : 0,
-      now2,
-      now2
+      now3,
+      now3
     );
     const newTaskId = Number(insertResult.lastInsertRowid);
     if (opts.blockedBy && opts.blockedBy.length > 0) {
@@ -9176,7 +9590,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, now2);
+        insertEdge.run(blocker.id, newTaskId, now3);
       }
     }
     const row = getTask(db, opts.localId, opts.workstream);
@@ -9231,7 +9645,7 @@ function addBlocksEdges(db, input, blocks, workstream) {
     }
     umbrellas.set(row.id, local);
   }
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
   const insertEdge = db.prepare(
     "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
   );
@@ -9242,10 +9656,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, now2);
+      insertEdge.run(newId, umbrellaId, now3);
     }
   }
-  for (const umbrellaId of umbrellas.keys()) touchTask(db, umbrellaId, now2);
+  for (const umbrellaId of umbrellas.keys()) touchTask(db, umbrellaId, now3);
 }
 function lookupEdgeTask(db, wsId, localId, workstream) {
   const row = db.prepare(
@@ -9278,18 +9692,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 now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__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, now2, opts.kind ?? "note");
-    if (touch) touchTask(db, taskId, now2);
+    ).run(taskId, opts.author ?? null, content, now3, opts.kind ?? "note");
+    if (touch) touchTask(db, taskId, now3);
     return r;
   }).immediate();
   return {
     author: opts.author ?? null,
     content,
-    createdAt: now2,
+    createdAt: now3,
     kind: opts.kind ?? "note"
   };
 }
@@ -9757,7 +10171,7 @@ async function claimTaskImpl(db, localId, opts) {
           throw new ClaimerNotRegisteredError(agentName, null);
         }
       }
-      const now2 = (/* @__PURE__ */ new Date()).toISOString();
+      const now3 = (/* @__PURE__ */ new Date()).toISOString();
       let result;
       try {
         result = db.prepare(
@@ -9771,7 +10185,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, now2, localId, opts.workstream, claimerRow.id);
+        ).run(claimerRow.id, now3, localId, opts.workstream, claimerRow.id);
       } catch (err) {
         if (err instanceof Error && err.message === GUARD_ALREADY_OWNED) {
           throw new TaskAlreadyOwnedError(localId, before.ownerName ?? "<unknown>");
@@ -9827,7 +10241,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 now2 = (/* @__PURE__ */ new Date()).toISOString();
+      const now3 = (/* @__PURE__ */ new Date()).toISOString();
       const result = db.prepare(
         `UPDATE tasks
             SET status = CASE WHEN status = 'OPEN' THEN 'IN_PROGRESS' ELSE status END,
@@ -9836,7 +10250,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(now2, localId, before.workstreamName);
+      ).run(now3, localId, before.workstreamName);
       if (result.changes === 0) {
         throw new TaskAlreadyOwnedError(localId, before.ownerName ?? "<unknown>");
       }
@@ -10301,7 +10715,8 @@ function remoteShellCommand(profile, a) {
     cmd: a.command,
     local_sock: a.localSock,
     remote_sock: remoteSock,
-    cwd: a.cwd
+    cwd: a.cwd,
+    ...a.jobFile !== void 0 ? { job_file: a.jobFile } : {}
   });
   const unset = LOCAL_ONLY_ENV.map((k) => `-u ${k}`).join(" ");
   return `exec env ${unset} /bin/sh -c ${shellQuote(filled)}`;
@@ -10699,16 +11114,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 now2 = (/* @__PURE__ */ new Date()).toISOString();
+    const now3 = (/* @__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), now2, baselinesJson);
+      ).run(caller, JSON.stringify(merged), now3, 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, now2, caller);
+      ).run(JSON.stringify(merged), baselinesJson, now3, caller);
     }
     const after = select(db, caller);
     if (after === void 0) throw new WaitRegistrationError("wait registration vanished");
@@ -10916,8 +11331,8 @@ async function closeRecovery(db, rec, opts) {
 }
 
 // src/agents/gate.ts
-import { randomUUID as randomUUID6 } from "crypto";
-var newGateToken = () => randomUUID6();
+import { randomUUID as randomUUID7 } from "crypto";
+var newGateToken = () => randomUUID7();
 var TOKEN_RE = /^[0-9a-f-]{36}$/;
 var DIR = `"$HOME"/.local/state/mu-next/remote-gates`;
 var sh = (body) => `sh -c ${shellQuote(body)}`;
@@ -10988,6 +11403,7 @@ async function readGate(db, agent) {
       { paneAlive: localPaneAlive }
     );
   } catch (e) {
+    if (e instanceof HostHandbackError) throw e;
     return unknown2(`result read: ${e instanceof Error ? e.message : String(e)}`);
   }
   if (!sameRow(db, agent)) return { kind: "dead", reason: "the agent was replaced" };
@@ -11021,6 +11437,71 @@ async function cleanGateResult(db, agent) {
   }
 }
 
+// src/agents/lease-carrier.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync3 } from "fs";
+import { dirname as dirname9 } from "path";
+import { setTimeout as delay } from "timers/promises";
+
+// src/carrier-stop.ts
+var CarrierStopRefusedError = class extends Error {
+  constructor(host, handle, why) {
+    super(say("carrier.stop_refused", host, handle, why));
+    this.host = host;
+    this.handle = handle;
+  }
+  host;
+  handle;
+  name = "CarrierStopRefusedError";
+};
+var CarrierStopFailedError = class extends Error {
+  constructor(host, handle, detail) {
+    super(say("carrier.stop_failed", host, handle, detail));
+    this.host = host;
+    this.handle = handle;
+    this.detail = detail;
+  }
+  host;
+  handle;
+  detail;
+  name = "CarrierStopFailedError";
+};
+var firstLine3 = (s) => s.split("\n").find((l) => l.trim() !== "")?.trim() ?? "";
+async function runStop(db, host, handle, hostStop, opts = {}) {
+  if (!JOB_HANDLE_RE.test(handle)) throw new CarrierStopRefusedError(host, handle, "bad-handle");
+  let current;
+  try {
+    current = getHost(db, host).stop;
+  } catch (e) {
+    if (e instanceof HostNotFoundError) throw new CarrierStopRefusedError(host, handle, "no-host");
+    throw e;
+  }
+  if (current !== hostStop) throw new CarrierStopRefusedError(host, handle, "stop-changed");
+  const run2 = await withHostChannel(
+    db,
+    host,
+    `stop:${handle}`,
+    (profile, lease) => {
+      if (profile.stop !== hostStop)
+        throw new CarrierStopRefusedError(host, handle, "stop-changed");
+      return runLeasedTemplate(
+        db,
+        lease,
+        profile,
+        "stop",
+        { job: handle, cwd: "." },
+        opts.timeoutMs ?? HOST_COMMAND_TIMEOUT_MS
+      );
+    },
+    opts
+  );
+  if (run2.exitCode === 0) return;
+  throw new CarrierStopFailedError(
+    host,
+    handle,
+    run2.exitCode === null ? "timed out" : `exit ${run2.exitCode}${firstLine3(run2.stderr) || firstLine3(run2.stdout) ? `: ${firstLine3(run2.stderr) || firstLine3(run2.stdout)}` : ""}`
+  );
+}
+
 // src/agents/lock.ts
 import { createHash as createHash4 } from "crypto";
 import { dirname as dirname8, join as join7 } from "path";
@@ -11222,7 +11703,312 @@ async function withSpawnAttemptLock(db, taskId, attemptKey, fn, onBusy) {
   );
 }
 
+// src/agents/lease-carrier.ts
+var LeaseJobTimeoutError = class extends Error {
+  constructor(agentName, host, budgetMs, jobFile) {
+    super(say("carrier.job_timeout", agentName, host, budgetMs, jobFile));
+    this.agentName = agentName;
+    this.host = host;
+    this.budgetMs = budgetMs;
+    this.jobFile = jobFile;
+  }
+  agentName;
+  host;
+  budgetMs;
+  jobFile;
+  name = "LeaseJobTimeoutError";
+};
+var LeaseJobInvalidError = class extends Error {
+  constructor(agentName, jobFile, line) {
+    super(say("carrier.job_invalid", agentName, jobFile, line));
+    this.agentName = agentName;
+    this.jobFile = jobFile;
+    this.line = line;
+  }
+  agentName;
+  jobFile;
+  line;
+  name = "LeaseJobInvalidError";
+};
+var LeaseJobUnreadableError = class extends Error {
+  constructor(agentName, jobFile, detail) {
+    super(say("carrier.job_unreadable", agentName, jobFile, detail));
+    this.agentName = agentName;
+    this.jobFile = jobFile;
+    this.detail = detail;
+  }
+  agentName;
+  jobFile;
+  detail;
+  name = "LeaseJobUnreadableError";
+};
+var DEFAULT_SPAWN_JOB_MS = 3e4;
+var realClock = { now: () => Date.now(), delay: (ms) => delay(ms) };
+var clock = realClock;
+var JOB_STAT_INTERVAL_MS = 50;
+var JOB_PANE_INTERVAL_MS = 250;
+function defaultSpawnJobMs() {
+  const parsed = Number.parseInt(process.env.MU_SPAWN_JOB_MS ?? "", 10);
+  return Number.isNaN(parsed) || parsed <= 0 ? DEFAULT_SPAWN_JOB_MS : parsed;
+}
+function leaseJobFile(db, workstream, name) {
+  return carrierJobFilePath(workstream, name, dirname9(db.name));
+}
+function readJobFile(path) {
+  let text;
+  try {
+    text = readFileSync3(path, "utf8");
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") return { kind: "none" };
+    return { kind: "unreadable", detail: code ?? (e instanceof Error ? e.message : String(e)) };
+  }
+  const line = text.split("\n")[0]?.trim() ?? "";
+  return JOB_HANDLE_RE.test(line) ? { kind: "handle", job: line } : { kind: "invalid", line };
+}
+var describeRead = (r) => r.kind === "handle" ? `handle ${r.job}` : r.kind === "invalid" ? `${JSON.stringify(r.line.slice(0, 80))}, not a handle` : r.kind === "unreadable" ? `unreadable: ${r.detail}` : "absent";
+function refuseReserved(db, workstream, name, own) {
+  const r = getCarrierJobByName(db, workstream, name);
+  if (r !== void 0 && r.token !== own) throw new CarrierJobUnstoppedError(name, r);
+}
+function assertLeaseSpawnable(profile, isGate) {
+  if (profile.transport === "lease" && isGate) {
+    throw new HostProfileError(say("carrier.lease_gate", profile.name));
+  }
+}
+async function reserveLeaseJob(db, workstream, name, profile) {
+  return withAgentLock(db, workstream, name, async () => {
+    if (getAgent(db, name, workstream) !== void 0) throw new AgentExistsError(name);
+    refuseReserved(db, workstream, name);
+    const r = reserveCarrierJob(db, {
+      workstream,
+      name,
+      host: profile.name,
+      hostStop: profile.stop ?? "",
+      creatorPid: process.pid,
+      creatorStart: pidStart(process.pid)
+    });
+    if (r !== void 0) return r;
+    refuseReserved(db, workstream, name);
+    throw new Error(`carrier_jobs: reservation of ${workstream}/${name} not inserted`);
+  });
+}
+function claimLeaseJobFile(db, workstream, name) {
+  const path = leaseJobFile(db, workstream, name);
+  mkdirSync3(dirname9(path), { recursive: true, mode: 448 });
+  const read = readJobFile(path);
+  if (read.kind === "none") return path;
+  const aside = `${path}.stale-${Date.now()}`;
+  renameSync2(path, aside);
+  try {
+    emitEvent(
+      db,
+      workstream,
+      "agent.spawn",
+      `agent spawn ${name}: a job file of an earlier reservation (${describeRead(read)}) moved to ${aside}`
+    );
+  } catch {
+  }
+  return path;
+}
+async function awaitLeaseJob(db, a) {
+  const budget = defaultSpawnJobMs();
+  const deadline = clock.now() + budget;
+  let lastPaneCheck = Number.NEGATIVE_INFINITY;
+  let scrollback;
+  for (; ; ) {
+    a.signal?.throwIfAborted();
+    const read = readJobFile(a.jobFile);
+    if (read.kind === "invalid") throw new LeaseJobInvalidError(a.name, a.jobFile, read.line);
+    if (read.kind === "unreadable") {
+      throw new LeaseJobUnreadableError(a.name, a.jobFile, read.detail);
+    }
+    if (read.kind === "handle") {
+      if (!fillCarrierJob(db, a.token, read.job)) {
+        throw new Error(say("carrier.job_unrecorded", a.name, read.job));
+      }
+      return read.job;
+    }
+    const atDeadline = clock.now() >= deadline;
+    if (atDeadline || clock.now() - lastPaneCheck >= JOB_PANE_INTERVAL_MS) {
+      lastPaneCheck = clock.now();
+      const mux = await activeMux();
+      scrollback = await mux.capture(a.paneId, { lines: 50 }).catch(() => void 0) ?? scrollback;
+      if (!await mux.paneAlive(a.paneId) && readJobFile(a.jobFile).kind === "none") {
+        throw new AgentDiedOnSpawnError(
+          a.name,
+          a.paneId,
+          scrollback,
+          a.command,
+          `before writing its job handle (up to ${budget}ms after spawn)`,
+          a.profile.name
+        );
+      }
+    }
+    if (atDeadline) throw new LeaseJobTimeoutError(a.name, a.profile.name, budget, a.jobFile);
+    await clock.delay(Math.min(JOB_STAT_INTERVAL_MS, Math.max(1, deadline - clock.now())));
+  }
+}
+async function rollbackLeaseJob(db, a, paneGone2) {
+  const jobFile = leaseJobFile(db, a.workstream, a.name);
+  const kept = (host, handle, why) => {
+    const line = handle === null ? say("carrier.rollback_reserved", a.name, a.workstream, host, why) : say("carrier.rollback_kept", a.name, a.workstream, host, handle, why);
+    try {
+      emitEvent(db, a.workstream, "agent.spawn_failed", `agent spawn rollback ${a.name}: ${line}`);
+    } catch {
+    }
+    if (!isJsonMode()) process.stderr.write(`${line}
+`);
+    return "kept";
+  };
+  try {
+    let job = getCarrierJob(db, a.token);
+    if (job === void 0) return kept("?", null, "its reservation is gone");
+    if (job.job === null) {
+      if (job.launch === "none") return "none";
+      const read = readJobFile(jobFile);
+      if (read.kind === "none") {
+        return kept(job.host, null, `no job handle in ${jobFile}; the carrier may still write one`);
+      }
+      if (read.kind !== "handle") {
+        const reason = `the job file ${jobFile} is ${describeRead(read)}`;
+        noteCarrierJob(db, job.token, reason);
+        return kept(job.host, null, reason);
+      }
+      if (!fillCarrierJob(db, job.token, read.job)) {
+        return kept(job.host, read.job, "the reservation holds another handle");
+      }
+      job = getCarrierJob(db, a.token);
+      if (job?.job == null) return kept("?", read.job, "its reservation is gone");
+    }
+    const handle = job.job;
+    if (!paneGone2 || job.paneId === null) {
+      return kept(job.host, handle, "its pane is not proven gone");
+    }
+    try {
+      await runStop(db, job.host, handle, job.hostStop);
+    } catch (e) {
+      return kept(job.host, handle, `stop failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const now3 = readJobFile(jobFile);
+    if (now3.kind === "handle" && now3.job === handle) rmSync3(jobFile, { force: true });
+    else if (now3.kind !== "none") {
+      return kept(job.host, handle, `stopped, but the job file ${jobFile} is ${describeRead(now3)}`);
+    }
+    return "stopped";
+  } catch (e) {
+    return kept("?", null, e instanceof Error ? e.message : String(e));
+  }
+}
+function releaseLeaseReservation(db, token, outcome) {
+  try {
+    const r = getCarrierJob(db, token);
+    if (r === void 0) return;
+    const ok = outcome === "stopped" ? r.job !== null : outcome === "none" && r.launch === "none" && r.job === null;
+    if (ok) releaseCarrierJob(db, r);
+  } catch {
+  }
+}
+async function describeEmptyReservation(db, r) {
+  const jobFile = leaseJobFile(db, r.workstream, r.name);
+  const creator = r.creatorPid === null ? "unknown" : pidProvenGone(r.creatorPid, r.creatorStart) ? "gone" : "not proven gone";
+  let pane = "none";
+  if (r.paneId !== null) {
+    const alive = await activeMux().then((m) => m.paneAlive(r.paneId ?? "")).catch(() => void 0);
+    pane = `${r.paneId} (${alive === void 0 ? "unknown" : alive ? "alive" : "dead"})`;
+  }
+  const facts = `launch ${r.launch}, pane ${pane}, creator pid ${r.creatorPid ?? "?"} ${creator}, job file ${describeRead(readJobFile(jobFile))}${r.reason === null ? "" : `, ${r.reason}`}`;
+  const unlaunched = r.launch === "none" && r.paneId === null && r.reason === null && creator === "gone";
+  return { facts, unlaunched };
+}
+function emitAbandoned(db, r, facts) {
+  emitEvent(
+    db,
+    r.workstream,
+    "agent.close",
+    say(
+      "carrier.reservation_abandoned",
+      r.name,
+      r.host,
+      leaseJobFile(db, r.workstream, r.name),
+      facts
+    )
+  );
+}
+async function stopLeaseReservation(db, reservation, opts = {}) {
+  let r = getCarrierJob(db, reservation.token);
+  if (r === void 0) return void 0;
+  const ws = r.workstream;
+  if (opts.abandon === true) {
+    const facts = r.job !== null ? `job ${r.job}${r.reason === null ? "" : `, ${r.reason}`}` : (await describeEmptyReservation(db, r)).facts;
+    if (!abandonCarrierJob(db, r)) {
+      throw new CarrierJobKeptError(r.name, ws, r.host, "the reservation changed during the close");
+    }
+    emitAbandoned(db, r, facts);
+    return { reservation: r, action: "abandon", facts };
+  }
+  if (r.job === null) {
+    const jobFile = leaseJobFile(db, ws, r.name);
+    const read = r.launch === "intent" ? readJobFile(jobFile) : { kind: "none" };
+    if (read.kind === "handle") {
+      if (!fillCarrierJob(db, r.token, read.job)) {
+        throw new CarrierJobUnresolvedError(r.name, ws, r.host, `the reservation changed`);
+      }
+      r = getCarrierJob(db, r.token);
+      if (r?.job == null) return void 0;
+    } else if (read.kind !== "none") {
+      const why = `the job file ${jobFile} is ${describeRead(read)}`;
+      noteCarrierJob(db, r.token, why);
+      throw new CarrierJobUnresolvedError(r.name, ws, r.host, why);
+    } else {
+      const { facts, unlaunched } = await describeEmptyReservation(db, r);
+      if (!unlaunched) {
+        const forTree = r.launch === "none" && r.paneId === null && r.reason !== null;
+        throw new CarrierJobUnresolvedError(r.name, ws, r.host, facts, forTree);
+      }
+      return { reservation: r, action: "unlaunched", facts };
+    }
+  }
+  const handle = r.job;
+  await runStop(db, r.host, handle, r.hostStop);
+  return { reservation: r, action: "stopped", facts: `job ${handle}` };
+}
+function cleanLeaseJobFile(db, close) {
+  if (close.action !== "stopped") return;
+  const r = close.reservation;
+  const jobFile = leaseJobFile(db, r.workstream, r.name);
+  const now3 = readJobFile(jobFile);
+  if (now3.kind === "none") return;
+  if (now3.kind === "handle" && now3.job === r.job) {
+    rmSync3(jobFile, { force: true });
+    return;
+  }
+  throw new CarrierJobKeptError(
+    r.name,
+    r.workstream,
+    r.host,
+    `job ${r.job} is stopped, but the job file ${jobFile} is ${describeRead(now3)}`
+  );
+}
+function releaseLeaseClose(db, close) {
+  if (close.action === "abandon") return;
+  const r = close.reservation;
+  if (!releaseCarrierJob(db, r)) {
+    if (getCarrierJob(db, r.token) === void 0) return;
+    throw new CarrierJobKeptError(
+      r.name,
+      r.workstream,
+      r.host,
+      "the reservation changed during the close (a job handle landed)"
+    );
+  }
+}
+
 // src/agents/close.ts
+function carrierJobOf(db, workstream, name) {
+  const r = getCarrierJobByName(db, workstream, name);
+  return r === void 0 ? null : { host: r.host, job: r.job, launch: r.launch, paneId: r.paneId, reason: r.reason };
+}
 function remoteOf(agent) {
   if (agent?.host == null || agent.cwd === null || agent.base === null) return null;
   return {
@@ -11247,17 +12033,18 @@ function worktreeOf(db, workstream, name, agent) {
 }
 async function previewClose(db, name, opts) {
   const discard = opts.discard === true;
+  const abandonJob = opts.abandonJob === true;
   for (let attempt = 0; attempt < 3; attempt++) {
     const agent = getAgentForCleanup(db, name, opts.workstream);
     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 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) {
+      const now3 = getAgentForCleanup(db, name, opts.workstream);
+      const nowRow = worktreeOf(db, opts.workstream, name, now3);
+      if (now3?.incarnation !== agent?.incarnation || now3?.paneId !== agent?.paneId || nowRow?.path !== row?.path) {
         return void 0;
       }
-      const rec = opts.recoveryId !== void 0 || now2 === void 0 && nowRow === void 0 ? selectRemoteRecovery(db, opts.workstream, name, opts.recoveryId) : void 0;
+      const rec = opts.recoveryId !== void 0 || now3 === 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,
@@ -11270,11 +12057,14 @@ async function previewClose(db, name, opts) {
           worktree: null,
           remote: null,
           recovery: null,
+          carrierJob: null,
           refusesDirty: false,
           discard,
-          keepBranch: opts.keepBranch === true
+          keepBranch: opts.keepBranch === true,
+          abandonJob
         };
       }
+      const carrierJob = carrierJobOf(db, opts.workstream, name);
       if (rec !== void 0) {
         return {
           agentName: name,
@@ -11286,25 +12076,29 @@ async function previewClose(db, name, opts) {
           ownedTasks: [],
           worktree: null,
           ...recoveryPreview(db, rec),
+          carrierJob,
           refusesDirty: false,
           discard,
-          keepBranch: opts.keepBranch === true
+          keepBranch: opts.keepBranch === true,
+          abandonJob
         };
       }
       return {
         agentName: name,
         workstream: opts.workstream,
-        kind: now2 ? "agent" : nowRow ? "orphan-worktree" : "none",
+        kind: now3 ? "agent" : nowRow ? "orphan-worktree" : carrierJob !== null ? "lease-job" : "none",
         revision: opts.recoveryId === void 0 ? agentRevision(db, opts.workstream, name) : 0,
-        incarnation: now2?.incarnation ?? null,
-        paneId: now2?.paneId ?? null,
-        ownedTasks: now2 ? ownedTasksOf(db, now2) : [],
+        incarnation: now3?.incarnation ?? null,
+        paneId: now3?.paneId ?? null,
+        ownedTasks: now3 ? ownedTasksOf(db, now3) : [],
         worktree: nowRow && state ? { path: nowRow.path, state } : null,
-        remote: remoteOf(now2),
+        remote: remoteOf(now3),
         recovery: null,
+        carrierJob,
         refusesDirty: state === "dirty" && !discard,
         discard,
-        keepBranch: opts.keepBranch === true
+        keepBranch: opts.keepBranch === true,
+        abandonJob
       };
     })();
     if (preview !== void 0) return preview;
@@ -11325,29 +12119,55 @@ async function closeLocked(db, name, opts) {
   };
   const agent = getAgentForCleanup(db, name, opts.workstream);
   const orphan = agent ? void 0 : getWorktreeFor(db, opts.workstream, name);
-  if (opts.recoveryId !== void 0 || agent === void 0 && orphan === void 0) {
-    const rec = selectRemoteRecovery(db, opts.workstream, name, opts.recoveryId);
-    if (rec === void 0) return { killedPane: false, deletedRow: false, worktree: null };
-    fence();
-    return closeRecovery(db, rec, {
-      keepBranch: opts.keepBranch === true,
-      force: opts.force === true
-    });
-  }
-  if (!agent) {
-    if (orphan === void 0) return { killedPane: false, deletedRow: false, worktree: null };
-    fence();
-    const worktree2 = await releaseWorktree(db, orphan, { discard, force: opts.force === true });
-    emitEvent(db, opts.workstream, "agent.close", closeLine(name, void 0, worktree2));
-    return { killedPane: false, deletedRow: false, worktree: worktree2 };
+  const nothing = { killedPane: false, deletedRow: false, worktree: null };
+  if (agent === void 0 || opts.recoveryId !== void 0) {
+    if (opts.recoveryId !== void 0 && selectRemoteRecovery(db, opts.workstream, name, opts.recoveryId) === void 0) {
+      return nothing;
+    }
+    const jobs = agent === void 0 ? listCarrierJobsByName(db, opts.workstream, name) : [];
+    if (jobs.length > 0) {
+      fence();
+      if (orphan === void 0) selectRemoteRecovery(db, opts.workstream, name, opts.recoveryId);
+    }
+    const closes2 = [];
+    for (const j of jobs) {
+      const c = await stopLeaseReservation(db, j, { abandon: opts.abandonJob === true });
+      if (c === void 0) continue;
+      cleanLeaseJobFile(db, c);
+      closes2.push(c);
+    }
+    const { result, tree } = await closeTreeWithoutRow(
+      db,
+      name,
+      opts,
+      orphan,
+      fence,
+      jobs.length > 0
+    );
+    for (const c of closes2) {
+      const r = c.reservation;
+      if (c.action === "stopped" && r.reason !== null && !closedKeptTree(r, tree)) {
+        throw new CarrierJobKeptError(
+          name,
+          opts.workstream,
+          r.host,
+          `job ${r.job} is stopped, but ${r.reason}${tree === void 0 ? "" : ` (the close handled ${tree.path} on ${tree.host}, another tree)`}`
+        );
+      }
+    }
+    if (closes2.length > 0) unlinkCtlSocket(db, name, opts.workstream);
+    for (const c of closes2) releaseLeaseClose(db, c);
+    if (closes2.length === 0) return result;
+    emitEvent(db, opts.workstream, "agent.close", closeLine(name, void 0, null, closes2));
+    return { ...result, carrierJobs: closes2.map(closedJob) };
   }
   const row = worktreeOf(db, opts.workstream, name, agent);
   if (row !== void 0) await assertReleasable(row, { discard });
   const mux = await activeMux().catch(() => void 0);
   const running = await runInFlight(agent);
   const replaced = () => {
-    const now2 = getAgentForCleanup(db, name, opts.workstream);
-    return now2 !== void 0 && !sameIncarnation(now2, agent);
+    const now3 = getAgentForCleanup(db, name, opts.workstream);
+    return now3 !== void 0 && !sameIncarnation(now3, agent);
   };
   if (replaced()) throw new AgentReplacedError(name, opts.workstream);
   fence();
@@ -11374,6 +12194,9 @@ async function closeLocked(db, name, opts) {
     throw new AgentPaneStillAliveError(name, agent.workstreamName, agent.paneId, alive, why);
   }
   if (replaced()) throw new AgentReplacedError(name, opts.workstream);
+  const lease = await stopAgentLease(db, agent, opts.abandonJob === true);
+  if (replaced()) throw new AgentReplacedError(name, opts.workstream);
+  if (lease !== void 0) cleanLeaseJobFile(db, lease);
   let worktree = null;
   let remoteHandled = false;
   if (row !== void 0)
@@ -11405,16 +12228,89 @@ async function closeLocked(db, name, opts) {
     { preserve: !remoteHandled }
   );
   if (!deletedRow && replaced()) throw new AgentReplacedError(name, opts.workstream);
+  if (lease !== void 0) releaseLeaseClose(db, lease);
   if (deletedRow && !running && openAtClose === 0)
     setAgentDone(db, agent.workstreamName, name, true);
-  emitEvent(db, agent.workstreamName, "agent.close", closeLine(name, agent.paneId, worktree));
-  return { killedPane: true, deletedRow, worktree };
-}
+  const closes = lease === void 0 ? [] : [lease];
+  emitEvent(
+    db,
+    agent.workstreamName,
+    "agent.close",
+    closeLine(name, agent.paneId, worktree, closes)
+  );
+  return {
+    killedPane: true,
+    deletedRow,
+    worktree,
+    ...lease === void 0 ? {} : { carrierJobs: [closedJob(lease)] }
+  };
+}
+function closedKeptTree(r, tree) {
+  return tree !== void 0 && r.treePath !== null && tree.host === r.host && tree.path === r.treePath && tree.agentId === r.treeAgentId;
+}
+async function closeTreeWithoutRow(db, name, opts, orphan, fence, fenced) {
+  const nothing = { killedPane: false, deletedRow: false, worktree: null };
+  if (opts.recoveryId !== void 0 || orphan === void 0) {
+    const rec = selectRemoteRecovery(db, opts.workstream, name, opts.recoveryId);
+    if (rec === void 0) return { result: nothing };
+    if (!fenced) fence();
+    const result = await closeRecovery(db, rec, {
+      keepBranch: opts.keepBranch === true,
+      force: opts.force === true
+    });
+    return { result, tree: { host: rec.host, path: rec.cwd, agentId: rec.agentId } };
+  }
+  if (!fenced) fence();
+  const worktree = await releaseWorktree(db, orphan, {
+    discard: opts.discard === true,
+    force: opts.force === true
+  });
+  emitEvent(db, opts.workstream, "agent.close", closeLine(name, void 0, worktree));
+  return { result: { ...nothing, worktree } };
+}
+async function stopAgentLease(db, agent, abandon) {
+  const jobs = listCarrierJobsByName(db, agent.workstreamName, agent.name);
+  const mine = jobs.find((j) => j.agentId === agent.incarnation) ?? jobs.find((j) => j.agentId === null);
+  if (mine !== void 0) return stopLeaseReservation(db, mine, { abandon });
+  if (agent.host === null || abandon) return void 0;
+  const file = leaseJobFile(db, agent.workstreamName, agent.name);
+  const read = readJobFile(file);
+  const transport = hostTransportOf(db, agent.incarnation);
+  const lease = transport === "lease" || transport === null && (read.kind !== "none" || isLeaseHost(db, agent.host));
+  if (!lease) return void 0;
+  throw new CarrierJobUnresolvedError(
+    agent.name,
+    agent.workstreamName,
+    agent.host,
+    read.kind === "none" ? `no carrier_jobs reservation records its job and no job file is at ${file}` : `no carrier_jobs reservation records its job, but its job file ${file} ${read.kind === "handle" ? `names ${read.job}: stop it by hand` : `is ${read.kind}`}`
+  );
+}
+function hostTransportOf(db, incarnation) {
+  const r = db.prepare("SELECT host_transport AS t FROM agents WHERE id = ?").get(incarnation);
+  return r?.t ?? null;
+}
+function isLeaseHost(db, host) {
+  try {
+    return getHost(db, host).transport === "lease";
+  } catch {
+    return false;
+  }
+}
+var closedJob = (c) => ({
+  host: c.reservation.host,
+  job: c.reservation.job,
+  action: c.action
+});
 function sameIncarnation(a, b) {
   return a.incarnation === b.incarnation && a.paneId === b.paneId;
 }
-function closeLine(name, paneId, wt) {
+function closeLine(name, paneId, wt, jobs = []) {
   const bits = [paneId === void 0 ? void 0 : `pane=${paneId}`];
+  for (const j of jobs) {
+    const what = j.reservation.job === null ? "lease reservation" : `job ${j.reservation.job}`;
+    const did = j.action === "stopped" ? "stopped" : j.action === "abandon" ? "abandoned" : "released";
+    bits.push(`${what} on ${j.reservation.host} ${did}`);
+  }
   if (wt !== null) {
     bits.push(`worktree ${wt.action}${wt.branch === void 0 ? "" : ` as ${wt.branch}`}`);
   }
@@ -11434,7 +12330,7 @@ function delegateOutcome(agent, timedOut) {
 }
 
 // src/agents/observe.ts
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 function observationFromReading(agent, reading) {
   return {
     workstream: agent.workstreamName,
@@ -11477,7 +12373,7 @@ function observationFromGate(agent, gate) {
 async function observeAgentStates(db, agents) {
   const gates = agents.filter((a) => a.gateToken !== null);
   const rest = agents.filter((a) => a.gateToken === null);
-  const readings = await readAgentStates(rest, { stateDir: dirname9(db.name) });
+  const readings = await readAgentStates(rest, { stateDir: dirname10(db.name) });
   const out = new Map(
     rest.map((a) => [agentKey(a), observationFromReading(a, readings.get(agentKey(a)))])
   );
@@ -11604,7 +12500,7 @@ async function watchAgentRun(agent, sock, signal, opts) {
 
 // src/delegates.ts
 import { createHash as createHash5 } from "crypto";
-import { dirname as dirname10, join as join8 } from "path";
+import { dirname as dirname11, join as join8 } from "path";
 
 // src/delegate-verdict.ts
 var VERDICT_LABELS = ["CONFIRMED", "REFUTED", "UNVERIFIED"];
@@ -11643,11 +12539,11 @@ ${body}`;
 
 // src/delegates.ts
 function delegateSessionDir(dbPath, workstream, task) {
-  return join8(dirname10(dbPath), "delegate-sessions", workstream, task);
+  return join8(dirname11(dbPath), "delegate-sessions", workstream, task);
 }
 function delegateProcessDir(dbPath, callId) {
   return join8(
-    dirname10(dbPath),
+    dirname11(dbPath),
     "delegate-process",
     createHash5("sha256").update(callId).digest("hex").slice(0, 16)
   );
@@ -11778,7 +12674,7 @@ function taskIdFor2(callId, label) {
   const h = createHash5("sha256").update(callId).digest("hex").slice(0, 8);
   return `delegate_${stem ? `${stem}_` : ""}${h}`;
 }
-var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var now2 = () => (/* @__PURE__ */ new Date()).toISOString();
 function registerDelegateCall(db, opts) {
   const state = opts.state ?? "queued";
   return withOpContext(
@@ -11836,7 +12732,7 @@ function registerDelegateCall(db, opts) {
         opts.record?.workstream ?? null,
         opts.record?.task ?? null,
         opts.request.label ?? null,
-        now(),
+        now2(),
         canonical2(opts.request)
       );
       return { call: mustGet(db, opts.callId), created: true };
@@ -11862,7 +12758,7 @@ function markDelegate(db, callId, to, extra = {}) {
                 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);
+      ).run(to, now2(), 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" });
@@ -11900,7 +12796,7 @@ function finishDelegate(db, callId, opts) {
   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);
+  ).run(now2(), callId);
   const outcome = opts.outcome === "done" && !opts.text?.trim() ? "empty" : opts.outcome;
   const answered = outcome === "done";
   const cancelled = outcome === "cancelled";
@@ -11947,7 +12843,7 @@ function finishDelegate(db, callId, opts) {
       });
       db.prepare(
         "UPDATE delegate_calls SET state = ?, verdict = ?, error = ?, updated_at = ? WHERE call_id = ?"
-      ).run(state, ok ? verdict : null, error ?? null, now(), callId);
+      ).run(state, ok ? verdict : null, error ?? null, now2(), callId);
       return {
         changed: true,
         state,
@@ -12041,12 +12937,12 @@ function getReceipt(db, taskId, attemptKey) {
   return row ? fromRaw2(row) : void 0;
 }
 function reserveReceipt(db, r) {
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__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, now2, now2);
+  ).run(r.taskId, r.attemptKey, r.name, r.workstream, r.requestSha, r.msgId, now3, now3);
   const row = getReceipt(db, r.taskId, r.attemptKey);
   if (row === void 0) throw new Error("spawn receipt vanished after reservation");
   return row;
@@ -12328,25 +13224,25 @@ async function drive(db, req, taskId, key, start, resumed, guard, keep = false)
     }
     req.spawn.signal?.throwIfAborted();
     const checked = db.transaction(() => {
-      const now2 = getAgentForCleanup(db, target.name, ws);
-      if (now2 === void 0 || now2.incarnation !== target.incarnation || now2.paneId !== target.paneId) {
+      const now3 = getAgentForCleanup(db, target.name, ws);
+      if (now3 === void 0 || now3.incarnation !== target.incarnation || now3.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 !== now2.incarnation) {
+      if (t.ownerId !== now3.incarnation) {
         if (t.ownerId !== null) {
           throw new TaskAlreadyOwnedError(req.task, t.ownerName ?? "<unknown>");
         }
-        throw new SpawnTaskStateError(req.task, `is no longer claimed by ${now2.name}`);
+        throw new SpawnTaskStateError(req.task, `is no longer claimed by ${now3.name}`);
       }
       const journaled = updateReceipt(db, taskId, key, {
         state: "sending",
-        transport: expectsCtl(now2, agentCtlSocket(db, now2)) ? "ctl" : "mux"
+        transport: expectsCtl(now3, agentCtlSocket(db, now3)) ? "ctl" : "mux"
       });
-      return { row: now2, rec: journaled };
+      return { row: now3, rec: journaled };
     }).immediate();
     row = checked.row;
     rec = checked.rec;
@@ -12458,13 +13354,13 @@ function idleThresholdMs() {
   if (!Number.isFinite(n) || n < 0) return DEFAULT_IDLE_THRESHOLD_MS;
   return n;
 }
-function computeAgentIdle(db, agent, now2 = Date.now()) {
+function computeAgentIdle(db, agent, now3 = 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 (now2 - since < threshold) return false;
+  if (now3 - since < threshold) return false;
   if (isScratchWorkstream(agent.workstreamName)) return true;
   const wsId = tryResolveWorkstreamId(db, agent.workstreamName);
   if (wsId === null) return false;
@@ -12529,15 +13425,19 @@ function agentIdByName(db, name, workstream) {
 function insertAgent(db, input) {
   ensureWorkstream(db, input.workstream);
   const workstreamId = resolveWorkstreamId(db, input.workstream);
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
+  let inserted;
   try {
-    db.prepare(
-      `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',
+    inserted = db.prepare(
+      `INSERT INTO agents (name, workstream_id, cli, pane_id, status, role, tab, cwd, base, command, command_source, spawner, host, collected_head, repo, gate_token, host_transport, created_at, updated_at)
+       SELECT @name, @workstreamId, COALESCE(@cli, 'pi'), @paneId, 'spawning',
                COALESCE(@role, 'full-access'), @tab, @cwd, @base, @command, @commandSource,
-               @spawner, @host, @collectedHead, @repo, @gateToken, @now, @now)`
+               @spawner, @host, @collectedHead, @repo, @gateToken, @hostTransport, @now, @now
+       WHERE NOT EXISTS (SELECT 1 FROM carrier_jobs c
+                         WHERE c.workstream = @workstream AND c.name = @name AND c.token IS NOT @reservation)`
     ).run({
       name: input.name,
+      workstream: input.workstream,
       workstreamId,
       cli: input.cli ?? null,
       paneId: input.paneId,
@@ -12552,14 +13452,21 @@ function insertAgent(db, input) {
       collectedHead: input.collectedHead ?? null,
       repo: input.repo ?? null,
       gateToken: input.gateToken ?? null,
-      now: now2
-    });
+      hostTransport: input.hostTransport ?? null,
+      reservation: input.reservation ?? null,
+      now: now3
+    }).changes;
   } catch (err) {
     if (err.code === "SQLITE_CONSTRAINT_UNIQUE") {
       throw new AgentExistsError(input.name);
     }
     throw err;
   }
+  if (inserted === 0) {
+    const r = getCarrierJobByName(db, input.workstream, input.name);
+    if (r !== void 0) throw new CarrierJobUnstoppedError(input.name, r);
+    throw new Error(`agents.insertAgent: row not inserted: ${input.name}`);
+  }
   const row = getAgent(db, input.name, input.workstream);
   if (!row) throw new Error(`agents.insertAgent: row not found after insert: ${input.name}`);
   return row;
@@ -12673,7 +13580,7 @@ async function readLiveAgents(db, workstream, only, states) {
   const baseAgents = listAgents(db, { workstream }).filter(
     (a) => only === void 0 || a.name === only
   );
-  const stateDir = dirname11(db.name);
+  const stateDir = dirname12(db.name);
   let readings;
   if (states === void 0) readings = await readAgentStates(baseAgents, { stateDir });
   else {
@@ -12683,7 +13590,7 @@ async function readLiveAgents(db, workstream, only, states) {
     }
     readings = states.cache;
   }
-  const now2 = Date.now();
+  const now3 = Date.now();
   return baseAgents.map((agent) => {
     const reading = readings.get(agentKey(agent)) ?? {
       state: "unknown",
@@ -12701,7 +13608,7 @@ 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, now2) ? { ...live2, idle: true } : live2;
+    return computeAgentIdle(db, live2, now3) ? { ...live2, idle: true } : live2;
   });
 }
 
@@ -12721,13 +13628,239 @@ async function withSpawnLock(session, fn, opts) {
   return withFileLock(lockPathForSession(session), session, fn, lockOpts);
 }
 
+// src/agents/spawn-ready.ts
+import { existsSync as existsSync5 } from "fs";
+import { setTimeout as delay2 } from "timers/promises";
+function probeToSpawnCtl(kind) {
+  return kind === "ok" ? "ok" : kind === "missing" ? "missing" : "refused";
+}
+function defaultSpawnCtlMs() {
+  const raw = process.env.MU_SPAWN_CTL_MS;
+  if (raw === void 0) return 3e4;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed < 0) return 3e4;
+  return parsed;
+}
+var CTL_POLL_INTERVAL_MS = 250;
+var CTL_STAT_INTERVAL_MS = 50;
+var handshakeClock = { now: () => Date.now(), delay: (ms) => delay2(ms) };
+async function awaitCtlHandshake(sock, onMiss, signal) {
+  const budgetMs = defaultSpawnCtlMs();
+  const deadline = handshakeClock.now() + budgetMs;
+  let last = "missing";
+  let lastMissAt = Number.NEGATIVE_INFINITY;
+  let first = true;
+  for (; ; ) {
+    signal?.throwIfAborted();
+    if (first || existsSync5(sock)) {
+      first = false;
+      const remaining = deadline - handshakeClock.now();
+      const probe = await ctlProbe(
+        sock,
+        Math.max(1, Math.min(remaining, CTL_POLL_INTERVAL_MS * 4))
+      );
+      if (probe.kind === "ok") {
+        return {
+          ctl: "ok",
+          ...probe.incarnation !== void 0 ? { incarnation: probe.incarnation } : {}
+        };
+      }
+      last = probeToSpawnCtl(probe.kind);
+    }
+    const atDeadline = handshakeClock.now() >= deadline;
+    if (onMiss && (atDeadline || handshakeClock.now() - lastMissAt >= CTL_POLL_INTERVAL_MS)) {
+      lastMissAt = handshakeClock.now();
+      await onMiss();
+    }
+    const left = deadline - handshakeClock.now();
+    if (left <= 0) return { ctl: last };
+    await handshakeClock.delay(Math.min(CTL_STAT_INTERVAL_MS, left));
+  }
+}
+function defaultSpawnLivenessMs() {
+  const raw = process.env.MU_SPAWN_LIVENESS_MS;
+  if (raw === void 0) return 1500;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed < 0) return 1500;
+  return parsed;
+}
+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
+];
+var EXEC_FAILURE_PATTERN = /^(?:.*: )?(?:command not found|No such file or directory)(?::\s*\S+)?$/i;
+var STARTUP_ERROR_TAIL_LINES = 30;
+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 patterns) {
+      if (pattern.test(line)) return line;
+    }
+  }
+  return void 0;
+}
+async function awaitSpawnLiveness(paneId, agentName, command, host) {
+  const ms = defaultSpawnLivenessMs();
+  if (ms === 0) return false;
+  await sleep2(ms);
+  return checkSpawnHealth(paneId, agentName, command, void 0, false, host);
+}
+var CLAUDE_TRUST_DIALOG = /Yes, I trust this folder/i;
+function detectClaudeTrustDialog(scrollback) {
+  const lines = scrollback.split(/\r?\n/);
+  const tail = lines.slice(Math.max(0, lines.length - STARTUP_ERROR_TAIL_LINES));
+  return tail.some((line) => CLAUDE_TRUST_DIALOG.test(line));
+}
+async function checkSpawnHealth(paneId, agentName, command, when, cliStarted = false, host) {
+  const mux = await activeMux();
+  const scrollback = await mux.capture(paneId, { lines: 50 }).catch(() => void 0);
+  if (!await mux.paneAlive(paneId)) {
+    throw new AgentDiedOnSpawnError(agentName, paneId, scrollback, command, when, host);
+  }
+  if (scrollback !== void 0) {
+    const matchedLine = detectSpawnStartupError(scrollback, cliStarted);
+    if (matchedLine !== void 0) {
+      throw new AgentSpawnStartupError(agentName, paneId, matchedLine, scrollback, when);
+    }
+    return detectClaudeTrustDialog(scrollback);
+  }
+  return false;
+}
+
+// src/agents/spawn-remote.ts
+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.worktree && opts.root === void 0 && profile.repo === null) {
+    throw new HostProfileError(
+      `host ${host} has no default repo: pass --root <remote repo path> with --worktree`
+    );
+  }
+  const mux = await activeMux();
+  if (!mux.runsShellCommand) throw new HostSpawnUnsupportedError(host, mux.name);
+  return profile;
+}
+async function prestageRemote(db, opts, cli, spawner, lease, profile, reservation) {
+  return withAgentLock(db, opts.workstream, opts.name, async () => {
+    const placeholder = insertAgent(db, {
+      ...reservation !== void 0 ? { reservation } : {},
+      name: opts.name,
+      workstream: opts.workstream,
+      cli,
+      paneId: pendingPaneIdFor(opts.name),
+      role: opts.role,
+      tab: opts.tab ?? null,
+      cwd: null,
+      spawner,
+      host: profile.name,
+      hostTransport: profile.transport
+    });
+    try {
+      const made = await prepareRemote(db, lease, profile, {
+        workstream: opts.workstream,
+        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(
+          (r) => r.host === profile.name
+        )
+      });
+      return {
+        path: made.cwd,
+        base: made.base ?? "",
+        root: made.repo ?? "",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        incarnation: placeholder.incarnation,
+        host: profile.name
+      };
+    } catch (err) {
+      try {
+        deleteAgent(db, opts.name, opts.workstream, { incarnation: placeholder.incarnation });
+      } catch {
+      }
+      throw err;
+    }
+  });
+}
+async function admitRemoteSpawn(db, opts, cli, spawner, profile, admit2, reservation) {
+  const admitted = await admitHostChannel(
+    db,
+    profile.name,
+    `spawn:${opts.workstream}/${opts.name}`,
+    { paneAlive: localPaneAlive }
+  );
+  const { lease } = admitted;
+  const admittedProfile = admitted.profile;
+  const transient = admittedProfile.transport === "lease";
+  try {
+    admit2?.(admittedProfile);
+    let staged;
+    let site;
+    if (opts.worktree) {
+      staged = await prestageRemote(db, opts, cli, spawner, lease, admittedProfile, reservation);
+    } else {
+      site = await prepareRemote(db, lease, admittedProfile, {
+        workstream: opts.workstream,
+        name: opts.name,
+        worktree: false,
+        ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+        ...remoteRoot(opts, admittedProfile)
+      });
+    }
+    if (transient) releaseHostChannel(db, lease);
+    return { lease: transient ? void 0 : lease, profile: admittedProfile, staged, site };
+  } catch (err) {
+    releaseHostChannel(db, lease);
+    throw err;
+  }
+}
+async function rollbackRemoteWorktree(db, name, workstream, staged, paneGone2) {
+  let remoteGone = false;
+  try {
+    if (!paneGone2) throw new Error("pane not proven gone");
+    await withAgentLock(db, workstream, name, async () => {
+      const cur = getAgent(db, name, workstream);
+      if (cur !== void 0 && cur.incarnation !== staged.incarnation) return;
+      remoteGone = await removeRemoteWorktree(
+        db,
+        staged.host ?? "",
+        `rollback:${workstream}/${name}`,
+        staged
+      );
+    });
+  } catch {
+    try {
+      emitEvent(
+        db,
+        workstream,
+        "agent.spawn_failed",
+        `agent spawn rollback ${name}: remote worktree ${staged.path} on ${staged.host} was not removed`
+      );
+    } catch {
+    }
+  }
+  return remoteGone;
+}
+
 // src/agents/staging.ts
 var STAGING_DEAD_MS = 6e4;
-function deadStagings(db, workstream, now2 = Date.now()) {
+function deadStagings(db, workstream, now3 = 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 now2 - Math.max(Date.parse(a.updatedAt), made ? Date.parse(made) : 0) > STAGING_DEAD_MS;
+    return now3 - Math.max(Date.parse(a.updatedAt), made ? Date.parse(made) : 0) > STAGING_DEAD_MS;
   });
 }
 async function reclaimDeadStagings(db, workstream) {
@@ -12816,7 +13949,7 @@ async function checkCommandResolvable(command) {
 var NEXT_FREE_ATTEMPTS = 32;
 var NEXT_FREE_LOOKUPS = 1e3;
 function nextFreeAgentName(db, name, workstream) {
-  const free = (n) => getAgent(db, n, workstream) === void 0 && !existsSync5(worktreePath(workstream, n));
+  const free = (n) => getAgent(db, n, workstream) === void 0 && getCarrierJobByName(db, workstream, n) === void 0 && !existsSync6(worktreePath(workstream, n));
   if (free(name)) return name;
   const m = /^(.*)-(\d+)$/.exec(name);
   const [stem, first] = m ? [m[1] ?? "", BigInt(m[2] ?? "1")] : [name, 1n];
@@ -12830,9 +13963,6 @@ function nextFreeAgentName(db, name, workstream) {
   }
   throw new AgentNameExhaustedError(name, `the next ${NEXT_FREE_LOOKUPS} names are taken`);
 }
-function probeToSpawnCtl(kind) {
-  return kind === "ok" ? "ok" : kind === "missing" ? "missing" : "refused";
-}
 function speaksMuCtl(cli, command) {
   if (cli === "pi") return true;
   const argv0 = basename2(parseFirstToken(command));
@@ -12844,49 +13974,6 @@ function isCommandGate(opts) {
   const argv0 = basename2(parseFirstToken(opts.command));
   return argv0 !== "pi" && argv0 !== "pi-meta";
 }
-function defaultSpawnCtlMs() {
-  const raw = process.env.MU_SPAWN_CTL_MS;
-  if (raw === void 0) return 3e4;
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed < 0) return 3e4;
-  return parsed;
-}
-var CTL_POLL_INTERVAL_MS = 250;
-var CTL_STAT_INTERVAL_MS = 50;
-var handshakeClock = { now: () => Date.now(), delay: (ms) => delay(ms) };
-async function awaitCtlHandshake(sock, onMiss, signal) {
-  const budgetMs = defaultSpawnCtlMs();
-  const deadline = handshakeClock.now() + budgetMs;
-  let last = "missing";
-  let lastMissAt = Number.NEGATIVE_INFINITY;
-  let first = true;
-  for (; ; ) {
-    signal?.throwIfAborted();
-    if (first || existsSync5(sock)) {
-      first = false;
-      const remaining = deadline - handshakeClock.now();
-      const probe = await ctlProbe(
-        sock,
-        Math.max(1, Math.min(remaining, CTL_POLL_INTERVAL_MS * 4))
-      );
-      if (probe.kind === "ok") {
-        return {
-          ctl: "ok",
-          ...probe.incarnation !== void 0 ? { incarnation: probe.incarnation } : {}
-        };
-      }
-      last = probeToSpawnCtl(probe.kind);
-    }
-    const atDeadline = handshakeClock.now() >= deadline;
-    if (onMiss && (atDeadline || handshakeClock.now() - lastMissAt >= CTL_POLL_INTERVAL_MS)) {
-      lastMissAt = handshakeClock.now();
-      await onMiss();
-    }
-    const left = deadline - handshakeClock.now();
-    if (left <= 0) return { ctl: last };
-    await handshakeClock.delay(Math.min(CTL_STAT_INTERVAL_MS, left));
-  }
-}
 async function spawnAgent3(db, opts) {
   await reclaimDeadStagings(db, opts.workstream);
   if (opts.nextFree === true) {
@@ -12909,6 +13996,7 @@ async function spawnAgent3(db, opts) {
   if (getAgent(db, opts.name, opts.workstream) !== void 0) {
     throw new AgentExistsError(opts.name);
   }
+  refuseReserved(db, opts.workstream, opts.name);
   const session = opts.tmuxSession ?? `mu-${opts.workstream}`;
   const windowName = opts.tab ?? opts.name;
   const cli = opts.cli ?? "pi";
@@ -12920,6 +14008,15 @@ async function spawnAgent3(db, opts) {
       "--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"
     );
   }
+  if (profile) assertLeaseSpawnable(profile, gateToken !== void 0);
+  const reservation = profile?.transport === "lease" ? await reserveLeaseJob(db, opts.workstream, opts.name, profile) : void 0;
+  const leaseCheck = (p) => {
+    assertLeaseSpawnable(p, gateToken !== void 0);
+    if (p.transport === "lease" !== (reservation !== void 0)) {
+      throw new HostProfileError(say("carrier.transport_changed", p.name));
+    }
+    if (reservation !== void 0) setCarrierJobStop(db, reservation.token, p.stop ?? "");
+  };
   const command = opts.command ?? (profile ? cli : resolved.command);
   const commandSource = opts.command !== void 0 ? "explicit" : !profile && resolved.resolvedFromEnv ? "env" : "cli-key";
   if (opts.command === void 0 && !profile) {
@@ -12934,32 +14031,28 @@ async function spawnAgent3(db, opts) {
   let site;
   try {
     if (profile) {
-      ({ lease, profile } = await admitHostChannel(
+      ({ lease, profile, staged, site } = await admitRemoteSpawn(
         db,
-        profile.name,
-        `spawn:${opts.workstream}/${opts.name}`,
-        { paneAlive: localPaneAlive }
+        opts,
+        cli,
+        spawner,
+        profile,
+        leaseCheck,
+        reservation?.token
       ));
-      if (opts.worktree) staged = await prestageRemote(db, opts, cli, spawner, lease, profile);
-      else
-        site = await prepareRemote(db, lease, profile, {
-          workstream: opts.workstream,
-          name: opts.name,
-          worktree: false,
-          ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
-          ...remoteRoot(opts, profile)
-        });
     } else if (opts.worktree) {
       staged = await prestageWorktree(db, opts, cli, spawner);
     }
   } catch (err) {
     if (lease !== void 0) releaseHostChannel(db, lease);
+    if (reservation !== void 0) releaseLeaseReservation(db, reservation.token, "none");
     emitSpawnFailed(db, opts, "worktree", err);
     throw err;
   }
   const paneCwd = staged?.path ?? site?.cwd ?? resolve3(opts.cwd ?? process.cwd());
-  const ctlSocket = ctlSocketPath(opts.workstream, opts.name, dirname12(db.name));
-  mkdirSync3(dirname12(ctlSocket), { recursive: true, mode: 448 });
+  const carrier = reservation !== void 0 ? { token: reservation.token } : void 0;
+  const ctlSocket = ctlSocketPath(opts.workstream, opts.name, dirname13(db.name));
+  mkdirSync4(dirname13(ctlSocket), { recursive: true, mode: 448 });
   const paneEnv = profile ? {} : {
     MU_MANAGED_AGENT: "1",
     MU_AGENT_NAME: opts.name,
@@ -12990,71 +14083,100 @@ async function spawnAgent3(db, opts) {
   let readiness = Promise.resolve();
   try {
     opts.signal?.throwIfAborted();
-    const created = await withSpawnLock(session, async () => {
-      if (!hasWorktree && getAgent(db, opts.name, opts.workstream) !== void 0) {
-        throw new AgentExistsError(opts.name);
-      }
-      if (staged !== void 0) {
-        const cur = getAgent(db, opts.name, opts.workstream);
-        if (cur === void 0 || cur.incarnation !== staged.incarnation || cur.paneId !== pendingPaneIdFor(opts.name)) {
-          throw new AgentReplacedError(opts.name, opts.workstream);
+    const created = await withAgentLock(
+      db,
+      opts.workstream,
+      opts.name,
+      () => withSpawnLock(session, async () => {
+        if (!hasWorktree && getAgent(db, opts.name, opts.workstream) !== void 0) {
+          throw new AgentExistsError(opts.name);
         }
-      }
-      rmSync3(ctlSocket, { force: true });
-      const mux = await activeMux();
-      if (isScratchWorkstream(opts.workstream)) await mux.ensureSession(session);
-      let onCreated = () => {
-      };
-      const createdPane = new Promise((res) => {
-        onCreated = res;
-      });
-      const done = mux.spawnAgent({
-        session,
-        window: windowName,
-        name: opts.name,
-        cli,
-        command: profile ? remoteShellCommand(profile, {
+        if (staged !== void 0) {
+          const cur = getAgent(db, opts.name, opts.workstream);
+          if (cur === void 0 || cur.incarnation !== staged.incarnation || cur.paneId !== pendingPaneIdFor(opts.name)) {
+            throw new AgentReplacedError(opts.name, opts.workstream);
+          }
+        }
+        refuseReserved(db, opts.workstream, opts.name, carrier?.token);
+        rmSync4(ctlSocket, { force: true });
+        const jobFile = carrier ? claimLeaseJobFile(db, opts.workstream, opts.name) : void 0;
+        const mux = await activeMux();
+        if (isScratchWorkstream(opts.workstream)) await mux.ensureSession(session);
+        const paneCommand = profile ? remoteShellCommand(profile, {
           workstream: opts.workstream,
           name: opts.name,
           command: gateToken === void 0 ? command : gateWrapper(command, gateToken),
           localSock: ctlSocket,
-          cwd: paneCwd
-        }) : command,
-        commandSource,
-        ...profile ? {} : { cwd: paneCwd },
-        env: paneEnv,
-        onPaneCreated: onCreated,
-        // A gate's pane outlives its command: the result is read after it ends.
-        ...gateToken !== void 0 ? { retainOnExit: true } : {}
-      });
-      done.catch(() => {
-      });
-      const pid = await Promise.race([createdPane, done]);
-      paneId = pid;
-      readiness = done;
-      phase = "finalize";
-      const row = finalizeAgentRow(db, {
-        opts,
-        cli,
-        paneId: pid,
-        cwd: paneCwd,
-        staged,
-        command,
-        commandSource,
-        spawner,
-        host: profile?.name,
-        gateToken
-      });
-      ownedIncarnation = row.incarnation;
-      if (lease !== void 0 && !bindHostChannel(db, lease, { agentId: row.incarnation, paneId: pid })) {
-        throw new Error(say("host.channel_lost", lease.host, lease.holder));
-      }
-      opts.onIdentity?.(row);
-      return { pid, row };
-    });
+          cwd: paneCwd,
+          ...jobFile !== void 0 ? { jobFile } : {}
+        }) : command;
+        let onCreated = () => {
+        };
+        const createdPane = new Promise((res) => {
+          onCreated = res;
+        });
+        if (carrier && !markCarrierLaunch(db, carrier.token)) {
+          throw new Error(`carrier_jobs: reservation of ${opts.workstream}/${opts.name} is gone`);
+        }
+        const done = mux.spawnAgent({
+          session,
+          window: windowName,
+          name: opts.name,
+          cli,
+          command: paneCommand,
+          commandSource,
+          ...profile ? {} : { cwd: paneCwd },
+          env: paneEnv,
+          onPaneCreated: onCreated,
+          // A gate's pane outlives its command: the result is read after it ends.
+          ...gateToken !== void 0 ? { retainOnExit: true } : {}
+        });
+        done.catch(() => {
+        });
+        const pid = await Promise.race([createdPane, done]);
+        paneId = pid;
+        if (carrier) recordCarrierPane(db, carrier.token, pid);
+        readiness = done;
+        phase = "finalize";
+        const row = finalizeAgentRow(db, {
+          opts,
+          cli,
+          paneId: pid,
+          cwd: paneCwd,
+          staged,
+          command,
+          commandSource,
+          spawner,
+          host: profile?.name,
+          hostTransport: profile?.transport,
+          gateToken,
+          reservation: carrier?.token
+        });
+        ownedIncarnation = row.incarnation;
+        if (carrier && !bindCarrierJobAgent(db, carrier.token, row.incarnation, pid)) {
+          throw new Error(`carrier_jobs: reservation of ${opts.workstream}/${opts.name} is gone`);
+        }
+        if (lease !== void 0 && !bindHostChannel(db, lease, { agentId: row.incarnation, paneId: pid })) {
+          throw new Error(say("host.channel_lost", lease.host, lease.holder));
+        }
+        opts.onIdentity?.(row);
+        return { pid, row, jobFile };
+      })
+    );
     paneId = created.pid;
     agent = created.row;
     phase = "liveness";
+    if (carrier && profile && created.jobFile !== void 0) {
+      await awaitLeaseJob(db, {
+        name: opts.name,
+        token: carrier.token,
+        paneId: created.pid,
+        profile,
+        jobFile: created.jobFile,
+        command,
+        ...opts.signal !== void 0 ? { signal: opts.signal } : {}
+      });
+    }
     if ((await activeMux()).spawnAgentWaitsReady) {
       await readiness;
     } else if (wantsCtl) {
@@ -13100,7 +14222,16 @@ async function spawnAgent3(db, opts) {
   } catch (err) {
     emitSpawnFailed(db, opts, phase, err);
     try {
-      await rollbackSpawn(db, opts.name, paneId, staged, ownedIncarnation, opts.workstream, lease);
+      await rollbackSpawn(
+        db,
+        opts.name,
+        paneId,
+        staged,
+        ownedIncarnation,
+        opts.workstream,
+        lease,
+        carrier
+      );
     } catch (cleanupErr) {
       if (err instanceof Error && err.cause === void 0) {
         try {
@@ -13190,65 +14321,6 @@ 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.worktree && opts.root === void 0 && profile.repo === null) {
-    throw new HostProfileError(
-      `host ${host} has no default repo: pass --root <remote repo path> with --worktree`
-    );
-  }
-  const mux = await activeMux();
-  if (!mux.runsShellCommand) throw new HostSpawnUnsupportedError(host, mux.name);
-  return profile;
-}
-async function prestageRemote(db, opts, cli, spawner, lease, profile) {
-  return withAgentLock(db, opts.workstream, opts.name, async () => {
-    const placeholder = insertAgent(db, {
-      name: opts.name,
-      workstream: opts.workstream,
-      cli,
-      paneId: pendingPaneIdFor(opts.name),
-      role: opts.role,
-      tab: opts.tab ?? null,
-      cwd: null,
-      spawner,
-      host: profile.name
-    });
-    try {
-      const made = await prepareRemote(db, lease, profile, {
-        workstream: opts.workstream,
-        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(
-          (r) => r.host === profile.name
-        )
-      });
-      return {
-        path: made.cwd,
-        base: made.base ?? "",
-        root: made.repo ?? "",
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        incarnation: placeholder.incarnation,
-        host: profile.name
-      };
-    } catch (err) {
-      try {
-        deleteAgent(db, opts.name, opts.workstream, { incarnation: placeholder.incarnation });
-      } catch {
-      }
-      throw err;
-    }
-  });
-}
 function spawnerFromEnv(env = process.env) {
   const { MU_MANAGED_AGENT: managed, MU_WORKSTREAM: ws, MU_AGENT_NAME: name } = env;
   if (managed === "1" && ws && name) return `${ws}/${name}`;
@@ -13257,8 +14329,10 @@ function spawnerFromEnv(env = process.env) {
 }
 function finalizeAgentRow(db, args) {
   const { opts, cli, paneId, cwd, staged, command, commandSource, spawner, host, gateToken } = args;
+  const hostTransport = args.hostTransport ?? null;
   if (staged === void 0) {
     return insertAgent(db, {
+      ...args.reservation !== void 0 ? { reservation: args.reservation } : {},
       name: opts.name,
       workstream: opts.workstream,
       cli,
@@ -13270,11 +14344,12 @@ function finalizeAgentRow(db, args) {
       commandSource,
       spawner,
       host: host ?? null,
+      hostTransport,
       gateToken: gateToken ?? null
     });
   }
   const patched = db.prepare(
-    `UPDATE agents SET pane_id = ?, cwd = ?, base = ?, command = ?, command_source = ?, spawner = ?, host = ?, repo = ?, updated_at = ?
+    `UPDATE agents SET pane_id = ?, cwd = ?, base = ?, command = ?, command_source = ?, spawner = ?, host = ?, host_transport = ?, repo = ?, updated_at = ?
       WHERE id = ? AND pane_id = ?
         AND name = ?
         AND workstream_id = (SELECT id FROM workstreams WHERE name = ?)`
@@ -13286,6 +14361,7 @@ function finalizeAgentRow(db, args) {
     commandSource,
     spawner,
     host ?? null,
+    hostTransport,
     staged.host !== void 0 ? staged.root : null,
     (/* @__PURE__ */ new Date()).toISOString(),
     staged.incarnation,
@@ -13310,7 +14386,12 @@ function emitSpawnFailed(db, opts, phase, err) {
   } catch {
   }
 }
-async function rollbackSpawn(db, name, paneId, staged, ownedIncarnation, workstream, lease) {
+function reservationOf(db, incarnation) {
+  if (incarnation === void 0) return void 0;
+  const r = getCarrierJobByAgent(db, incarnation);
+  return r === void 0 ? void 0 : { token: r.token };
+}
+async function rollbackSpawn(db, name, paneId, staged, ownedIncarnation, workstream, lease, carrier) {
   let paneGone2 = paneId === void 0;
   if (paneId !== void 0) {
     const mux = await activeMux().catch(() => void 0);
@@ -13341,32 +14422,12 @@ async function rollbackSpawn(db, name, paneId, staged, ownedIncarnation, workstr
     } catch {
     }
   }
+  carrier ??= reservationOf(db, ownedIncarnation);
+  const job = carrier ? await rollbackLeaseJob(db, { workstream, name, token: carrier.token }, paneGone2) : void 0;
   let remoteGone = false;
   if (staged?.host !== void 0) {
-    const remote = staged;
-    try {
-      if (!paneGone2) throw new Error("pane not proven gone");
-      await withAgentLock(db, workstream, name, async () => {
-        const cur = getAgent(db, name, workstream);
-        if (cur !== void 0 && cur.incarnation !== remote.incarnation) return;
-        remoteGone = await removeRemoteWorktree(
-          db,
-          remote.host ?? "",
-          `rollback:${workstream}/${name}`,
-          remote
-        );
-      });
-    } catch {
-      try {
-        emitEvent(
-          db,
-          workstream,
-          "agent.spawn_failed",
-          `agent spawn rollback ${name}: remote worktree ${staged.path} on ${staged.host} was not removed`
-        );
-      } catch {
-      }
-    }
+    if (job !== "kept")
+      remoteGone = await rollbackRemoteWorktree(db, name, workstream, staged, paneGone2);
   } else if (staged !== void 0 && paneGone2) {
     const say2 = (what) => {
       try {
@@ -13410,60 +14471,20 @@ async function rollbackSpawn(db, name, paneId, staged, ownedIncarnation, workstr
   }
   if (ownedIncarnation !== void 0)
     deleteAgent(db, name, workstream, { incarnation: ownedIncarnation }, { preserve: !remoteGone });
-}
-function defaultSpawnLivenessMs() {
-  const raw = process.env.MU_SPAWN_LIVENESS_MS;
-  if (raw === void 0) return 1500;
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed < 0) return 1500;
-  return parsed;
-}
-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
-];
-var EXEC_FAILURE_PATTERN = /^(?:.*: )?(?:command not found|No such file or directory)(?::\s*\S+)?$/i;
-var STARTUP_ERROR_TAIL_LINES = 30;
-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 patterns) {
-      if (pattern.test(line)) return line;
-    }
+  const treeDone = staged?.host === void 0 || remoteGone;
+  if (carrier && (job === "none" || job === "stopped")) {
+    if (treeDone) releaseLeaseReservation(db, carrier.token, job);
+    else keepForTree(db, carrier.token, staged);
   }
-  return void 0;
 }
-async function awaitSpawnLiveness(paneId, agentName, command, host) {
-  const ms = defaultSpawnLivenessMs();
-  if (ms === 0) return false;
-  await sleep2(ms);
-  return checkSpawnHealth(paneId, agentName, command, void 0, false, host);
-}
-var CLAUDE_TRUST_DIALOG = /Yes, I trust this folder/i;
-function detectClaudeTrustDialog(scrollback) {
-  const lines = scrollback.split(/\r?\n/);
-  const tail = lines.slice(Math.max(0, lines.length - STARTUP_ERROR_TAIL_LINES));
-  return tail.some((line) => CLAUDE_TRUST_DIALOG.test(line));
-}
-async function checkSpawnHealth(paneId, agentName, command, when, cliStarted = false, host) {
-  const mux = await activeMux();
-  const scrollback = await mux.capture(paneId, { lines: 50 }).catch(() => void 0);
-  if (!await mux.paneAlive(paneId)) {
-    throw new AgentDiedOnSpawnError(agentName, paneId, scrollback, command, when, host);
-  }
-  if (scrollback !== void 0) {
-    const matchedLine = detectSpawnStartupError(scrollback, cliStarted);
-    if (matchedLine !== void 0) {
-      throw new AgentSpawnStartupError(agentName, paneId, matchedLine, scrollback, when);
-    }
-    return detectClaudeTrustDialog(scrollback);
+function keepForTree(db, token, staged) {
+  try {
+    const reason = `remote worktree ${staged?.path ?? "?"} on ${staged?.host ?? "?"} was not removed`;
+    if (staged === void 0) noteCarrierJob(db, token, reason);
+    else
+      keepCarrierJobForTree(db, token, { path: staged.path, agentId: staged.incarnation, reason });
+  } catch {
   }
-  return false;
 }
 
 // src/agents/errors.ts
@@ -13487,6 +14508,59 @@ var AgentExistsError = class extends Error {
   agentName;
   name = "AgentExistsError";
 };
+var CarrierJobUnstoppedError = class extends Error {
+  constructor(agentName, reservation) {
+    const reason = reservation.reason ?? null;
+    super(
+      reservation.job !== null ? say("carrier.job_unstopped", agentName, reservation.job, reservation.host, reason) : say(
+        "carrier.job_reserved",
+        agentName,
+        reservation.host,
+        reservation.launch,
+        reservation.paneId,
+        reason
+      )
+    );
+    this.agentName = agentName;
+    this.handle = reservation.job;
+    this.host = reservation.host;
+    this.reason = reason;
+  }
+  agentName;
+  name = "CarrierJobUnstoppedError";
+  handle;
+  host;
+  /** Why the reservation was kept without a handle (e.g. a remote tree its rollback did not remove). */
+  reason;
+};
+var CarrierJobUnresolvedError = class extends Error {
+  constructor(agentName, workstream, host, facts, keptForTree = false) {
+    super(say("carrier.job_unresolved", agentName, workstream, host, facts, keptForTree));
+    this.agentName = agentName;
+    this.workstream = workstream;
+    this.host = host;
+    this.facts = facts;
+  }
+  agentName;
+  workstream;
+  host;
+  facts;
+  name = "CarrierJobUnresolvedError";
+};
+var CarrierJobKeptError = class extends Error {
+  constructor(agentName, workstream, host, why) {
+    super(say("carrier.job_kept", agentName, workstream, host, why));
+    this.agentName = agentName;
+    this.workstream = workstream;
+    this.host = host;
+    this.why = why;
+  }
+  agentName;
+  workstream;
+  host;
+  why;
+  name = "CarrierJobKeptError";
+};
 var AgentNameExhaustedError = class extends Error {
   constructor(agentName, reason) {
     super(say("agent.name_exhausted", agentName, reason));
@@ -13957,6 +15031,19 @@ export {
   setMuxForTests,
   resetMux,
   mux_exports,
+  reserveCarrierJob,
+  getCarrierJob,
+  getCarrierJobByAgent,
+  getCarrierJobByName,
+  listCarrierJobsByName,
+  listCarrierJobs,
+  markCarrierLaunch,
+  recordCarrierPane,
+  bindCarrierJobAgent,
+  fillCarrierJob,
+  noteCarrierJob,
+  releaseCarrierJob,
+  abandonCarrierJob,
   HostProfileError,
   HostTemplateError,
   HostNotFoundError,
@@ -13964,17 +15051,22 @@ export {
   HostChannelBusyError,
   HostInUseError,
   HostSpawnUnsupportedError,
+  HostHandbackError,
   HostCheckFailedError,
+  HOST_TRANSPORTS,
+  JOB_HANDLE_RE,
   isValidHostName,
   getHost,
   listHosts,
   addHost,
   removeHost,
   hostStarter,
+  hostMuleStarter,
   HOST_PLACEHOLDERS,
   HOST_ENV_KEYS,
   hostEnvWords,
   validateHostTemplate,
+  placeholderUses,
   expandHostTemplate,
   listHostChannels,
   reserveHostChannel,
@@ -14154,10 +15246,16 @@ export {
   agentOwed,
   hasDoneMark,
   setAgentDone,
+  CarrierStopRefusedError,
+  CarrierStopFailedError,
+  runStop,
   locksDir,
   withFileLock,
   readFileLockMeta,
   withAgentLock,
+  LeaseJobTimeoutError,
+  LeaseJobInvalidError,
+  LeaseJobUnreadableError,
   previewClose,
   closeAgent,
   delegateOutcome,
@@ -14200,6 +15298,7 @@ export {
   listLiveAgents,
   readLiveAgents,
   tmux_exports,
+  defaultSpawnLivenessMs,
   deadStagings,
   resolveCliCommand,
   envVarNameForCli2 as envVarNameForCli,
@@ -14211,9 +15310,11 @@ export {
   isCommandGate,
   spawnAgent3 as spawnAgent,
   spawnerFromEnv,
-  defaultSpawnLivenessMs,
   AgentSpawnCliNotFoundError,
   AgentExistsError,
+  CarrierJobUnstoppedError,
+  CarrierJobUnresolvedError,
+  CarrierJobKeptError,
   AgentNameExhaustedError,
   AgentNotFoundError,
   AgentNotInWorkstreamError,
@@ -14256,4 +15357,4 @@ export {
   murmurAvailable,
   readAgentStates
 };
-//# sourceMappingURL=chunk-L7I3BLXP.js.map
+//# sourceMappingURL=chunk-4ZWBLTZK.js.map