toyon 0.23.0 → 0.24.0

package/dist/daemon.js

@@ -2,7 +2,7 @@
 // ../daemon/src/index.ts
 import { rmSync as rmSync10, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir15 } from "os";
-import { dirname as dirname16, join as join36 } from "path";
+import { dirname as dirname16, join as join37 } from "path";
 import { fileURLToPath } from "url";
 
 // ../shared/src/protocol/events.ts
@@ -649,6 +649,9 @@ function movedPastLand(wt, f) {
 function prTaken(wt) {
   return !!wt.pr && (wt.lands ?? []).some((l) => l.pr === wt.pr?.number);
 }
+function prPending(wt) {
+  return !!wt.pr && wt.pr.state !== "closed" && !prTaken(wt);
+}
 function shipNoun(op) {
   return { land: "a land", commit: "a commit", "sync-main": "a sync", "pull-main": "a pull" }[op];
 }
@@ -6784,7 +6787,7 @@ ${text.slice(text.length - (CONTEXT_CHARS - HEAD_CHARS))}`;
 }
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 148;
+var PROTOCOL_VERSION = 149;
 var PAGE_ERROR_MAX_CHARS = 2000;
 var PAGE_TITLE_MAX_CHARS = 1000;
 var FILE_MAX_CHARS = 5000000;
@@ -7200,7 +7203,7 @@ var clientMsgSchema = discriminatedUnion("t", [
     base: string2().max(64).nullable(),
     seq
   }),
-  object({ t: literal("list-files"), worktreeId: id }),
+  object({ t: literal("list-files"), worktreeId: id, tracked: boolean2() }),
   object({ t: literal("list-commands"), worktreeId: id }),
   object({ t: literal("search"), worktreeId: id, query: string2().max(500) }),
   object({ t: literal("search-stop") }),
@@ -8841,7 +8844,7 @@ async function turnRemoteOff(ts, daemonPort, file, was) {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.23.0",
+  version: "0.24.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -13347,7 +13350,7 @@ class RemoteSetting {
   }
 }
 function sameSecret(given, want) {
-  if (given === null)
+  if (given === null || want === "")
     return false;
   const a = Buffer.from(given);
   const b = Buffer.from(want);
@@ -13451,7 +13454,7 @@ function passPreview(req, gate) {
   const code = url.searchParams.get(PREVIEW_GRANT_PARAM);
   if (code !== null) {
     url.searchParams.delete(PREVIEW_GRANT_PARAM);
-    const location = `${url.pathname}${url.search}`;
+    const location = `${url.pathname.replace(/^\/+/, "/")}${url.search}`;
     if (!pass.ok && !gate.redeem(code))
       return { ok: false, response: refusedPreview() };
     const headers = { location, "cache-control": "no-store" };
@@ -14104,6 +14107,13 @@ var NO_PROMPT = {
   GIT_SSH_COMMAND: "ssh -o BatchMode=yes"
 };
 var SPAWN_ENV = { GIT_OPTIONAL_LOCKS: "0" };
+function spawnEnv(base = process.env, ...over) {
+  const { LC_ALL: all, LANGUAGE: _language, ...rest } = base;
+  return Object.assign(rest, all ? { LANG: all } : {}, { LC_MESSAGES: "C" }, SPAWN_ENV, ...over);
+}
+function nulSplit(out) {
+  return out.split("\x00").filter(Boolean);
+}
 var RUN_CEILING_MS = 10 * 60000;
 async function run(cmd, args, cwd, env, opts = {}) {
   const started = Date.now();
@@ -14117,7 +14127,7 @@ async function run(cmd, args, cwd, env, opts = {}) {
       stdout: "pipe",
       stderr: "pipe",
       stdin: "ignore",
-      env: { ...process.env, ...SPAWN_ENV, ...env }
+      env: spawnEnv(process.env, env)
     });
     const done = (async () => {
       const [rawOut, err, status] = await Promise.all([
@@ -14159,7 +14169,7 @@ async function runLive(cmd, args, cwd, opts = {}) {
       stdout: "pipe",
       stderr: "pipe",
       stdin: "ignore",
-      env: { ...process.env, ...SPAWN_ENV, ...opts.env }
+      env: spawnEnv(process.env, opts.env)
     });
     const stop = () => p.kill();
     opts.signal?.addEventListener("abort", stop, { once: true });
@@ -14215,7 +14225,7 @@ async function runRows(cmd, args, cwd, opts) {
       stdout: "pipe",
       stderr: "pipe",
       stdin: "ignore",
-      env: { ...process.env, ...SPAWN_ENV }
+      env: spawnEnv()
     });
     const reader = p.stdout.getReader();
     const stop = () => {
@@ -14342,7 +14352,7 @@ function runWatched(cmd, args, cwd, opts = {}) {
         cwd,
         stdio: opts.onHook ? ["ignore", "pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
         detached: true,
-        env: { ...process.env, ...SPAWN_ENV, ...opts.env, ...opts.onHook ? { GIT_TRACE2_EVENT: "3" } : {} }
+        env: spawnEnv(process.env, opts.env, opts.onHook ? { GIT_TRACE2_EVENT: "3" } : undefined)
       });
     } catch (e) {
       failed(e instanceof Error ? e.message : String(e));
@@ -16635,6 +16645,12 @@ function handoffActedPrompt(pieces, outcomes, by = "plan", note) {
   }
   return `Toyon acted on the pieces you handed over with the plan's approval: ${parts.join("; ")}. ${own} The siblings read the plan at its path in this worktree; never do their pieces yourself.`;
 }
+function handoffDeclinedPrompt(pieces, note) {
+  const titles = pieces.map((p) => `"${p.title}"`).join(", ");
+  return `The person answered the handoff card with not now: nothing on the list you handed over (${titles}) was started, and none of it is yours to do from that list. They added: ${note}
+
+Read that as the word on what to change. Hand over a new list with the handoff tool if a split still fits, or go on without one.`;
+}
 function sentFromLine(path, by) {
   const who = by ? `, where ${by} was working` : "";
   return `This message was sent from a terminal in ${path} with \`toyon send\`${who}.`;
@@ -17563,7 +17579,7 @@ class AcpSession {
   steered = [];
   steerMark;
   streamingId;
-  refused = null;
+  refused = [];
   turn = null;
   stopped = false;
   holds = 0;
@@ -17571,6 +17587,7 @@ class AcpSession {
     return this.holds > 0;
   }
   conn = null;
+  start = null;
   connecting = null;
   opening = null;
   live = null;
@@ -17744,7 +17761,7 @@ class AcpSession {
     }
   }
   get runningAgent() {
-    return this.conn?.spec.id ?? null;
+    return this.conn?.spec.id ?? this.start?.spec.id ?? null;
   }
   get mcpTools() {
     return this.conn ? this.conn.mcpServers.length > 0 : null;
@@ -17783,7 +17800,7 @@ class AcpSession {
     return this.queue.length;
   }
   get unsettled() {
-    return this.queue.length > 0 || this.steered.length > 0 || this.refused !== null;
+    return this.queue.length > 0 || this.steered.length > 0 || this.refused.length > 0;
   }
   get queueItems() {
     return this.waiting().map(queued);
@@ -18023,7 +18040,8 @@ class AcpSession {
         const rejected = !isAuthRequired(e);
         if (rejected && !aws)
           this.emit({ type: "agent-error", message: this.describe(e), ts: Date.now() });
-        this.refused = item;
+        if (item)
+          this.refused.push(item);
         this.emit({
           type: "agent-auth-required",
           agent: this.conn.spec.id,
@@ -18059,9 +18077,12 @@ class AcpSession {
     if (!turn?.open)
       return;
     turn.open = false;
+    this.turnOver(stopReason);
+    this.setStopping(false);
+  }
+  turnOver(stopReason) {
     this.emit({ type: "turn-end", stopReason, ts: Date.now() });
     this.showHeld();
-    this.setStopping(false);
   }
   async ask(system, prompt, opts = {}) {
     if (this.stopped)
@@ -18116,6 +18137,7 @@ class AcpSession {
         }
       };
     }
+    this.armReaper();
     try {
       await conn.ctx.request(methods.agent.authenticate, {
         methodId,
@@ -18149,10 +18171,14 @@ class AcpSession {
     this.retry();
   }
   retry() {
-    const item = this.refused;
-    this.refused = null;
-    if (item && !this.stopped)
-      this.enqueue(item);
+    const items = this.refused;
+    this.refused = [];
+    if (items.length === 0 || this.stopped)
+      return;
+    this.queue.unshift(...items);
+    this.queueChanged();
+    if (!this.running && !this.held)
+      fireAndForget(this.d.worktreeId, this.drain(), "agent drain");
   }
   planWithheld(conn, methodId) {
     return this.d.planSignIn?.() === false && conn.spec.terminalLogins?.[methodId]?.plan === true;
@@ -18259,40 +18285,43 @@ class AcpSession {
       return Promise.resolve(this.conn);
     if (this.connecting)
       return this.connecting;
-    this.connecting = this.openConn(why).finally(() => {
-      this.connecting = null;
+    const connecting = this.openConn(why).finally(() => {
+      if (this.connecting === connecting)
+        this.connecting = null;
     });
-    return this.connecting;
+    this.connecting = connecting;
+    return connecting;
   }
   async openConn(why) {
+    if (this.stopped)
+      throw new UserError("this worktree's agent is closed");
     const spec = this.d.spec();
-    const prepared = await (this.d.prepare ?? prepareLaunch)(this.d.cwd, spec);
-    const { bounds } = prepared;
-    const sandboxed = spec.confinement !== "none";
-    const side = new Map;
-    const commands = new Map;
-    const app = client({ name: "toyon" }).onRequest(methods.client.session.requestPermission, (c) => this.onPermission(c.params, bounds, sandboxed)).onRequest(methods.client.elicitation.create, (c) => this.onElicit(c.params, c.signal)).onNotification(methods.client.session.update, (c) => this.onUpdate(c.params, side, commands)).onNotification(AUTH_STATUS_UPDATE_METHOD, parseAuthStatus, (c) => {
-      if (c.params)
-        this.d.onAuth?.(spec.id, { status: c.params });
-    });
-    const link = this.d.connect(app, spec, prepared);
-    this.noteProcess(link, true);
-    log.info(this.d.worktreeId, `agent ${spec.id} started for ${why} (pid ${link.pid ?? "unknown"})`);
-    const ctx = link.conn.agent;
-    link.exited.then(() => {
-      this.noteProcess(link, false);
-      if (this.conn?.link === link) {
-        log.warn(this.d.worktreeId, "agent process exited while idle");
-        this.conn = null;
-        this.live = null;
-        this.d.mcp?.close();
-        this.cancelAsks();
-        this.tasks.endAll("the agent stopped, and the command with it");
-        this.wakeups.endAll("the agent stopped before it woke");
-        this.endOwn("interrupted");
-      }
-    });
+    const start = { spec, link: null };
+    this.start = start;
     try {
+      const prepared = await (this.d.prepare ?? prepareLaunch)(this.d.cwd, spec);
+      if (this.start !== start)
+        throw stoppedStarting();
+      const { bounds } = prepared;
+      const sandboxed = spec.confinement !== "none";
+      const side = new Map;
+      const commands = new Map;
+      const app = client({ name: "toyon" }).onRequest(methods.client.session.requestPermission, (c) => this.onPermission(c.params, bounds, sandboxed)).onRequest(methods.client.elicitation.create, (c) => this.onElicit(c.params, c.signal)).onNotification(methods.client.session.update, (c) => this.onUpdate(c.params, side, commands)).onNotification(AUTH_STATUS_UPDATE_METHOD, parseAuthStatus, (c) => {
+        if (c.params)
+          this.d.onAuth?.(spec.id, { status: c.params });
+      });
+      const link = this.d.connect(app, spec, prepared);
+      start.link = link;
+      this.noteProcess(link, true);
+      log.info(this.d.worktreeId, `agent ${spec.id} started for ${why} (pid ${link.pid ?? "unknown"})`);
+      const ctx = link.conn.agent;
+      link.exited.then(() => {
+        this.noteProcess(link, false);
+        if (this.conn?.link === link) {
+          log.warn(this.d.worktreeId, "agent process exited while idle");
+          this.processGone();
+        }
+      });
       const init = await ctx.request(methods.agent.initialize, {
         protocolVersion: PROTOCOL_VERSION2,
         clientCapabilities: {
@@ -18302,7 +18331,9 @@ class AcpSession {
         },
         clientInfo: { name: "toyon", version: "0" }
       });
-      this.conn = {
+      if (this.start !== start)
+        throw stoppedStarting();
+      const conn = {
         link,
         ctx,
         spec,
@@ -18318,10 +18349,17 @@ class AcpSession {
         commands
       };
       this.d.onAuth?.(spec.id, { canLogout: supportsLogout(init.agentCapabilities) });
-      return this.conn;
+      this.start = null;
+      this.conn = conn;
+      return conn;
     } catch (e) {
-      fireAndForget(this.d.worktreeId, link.kill(), "kill agent after failed start");
-      this.noteProcess(link, false);
+      if (this.start !== start)
+        throw stoppedStarting();
+      this.start = null;
+      if (start.link) {
+        fireAndForget(this.d.worktreeId, start.link.kill(), "kill agent after failed start");
+        this.noteProcess(start.link, false);
+      }
       throw e;
     }
   }
@@ -18376,6 +18414,8 @@ class AcpSession {
       if (!this.stopped)
         this.d.setSessionId(sessionId);
     }
+    if (this.conn !== conn)
+      throw stoppedStarting();
     const options = readOptions(configOptions);
     this.emit({ type: "session-info", sessionId, ...currentValues(options) });
     this.learn(options, !resumed);
@@ -18764,7 +18804,7 @@ class AcpSession {
     if (this.own.settle)
       clearTimeout(this.own.settle);
     this.own = null;
-    this.emit({ type: "turn-end", stopReason, ts: Date.now() });
+    this.turnOver(stopReason);
     this.syncStatus();
     this.maybeArmReaper();
   }
@@ -18792,22 +18832,33 @@ class AcpSession {
       clearTimeout(this.reaper);
     this.reaper = null;
   }
-  async dropConn(why) {
-    this.cancelAsks();
-    this.tasks.endAll("the agent stopped, and the command with it");
-    this.wakeups.endAll("the agent stopped before it woke");
-    const conn = this.conn;
+  processGone() {
+    const was = this.conn ?? this.start;
     this.conn = null;
     this.live = null;
+    this.start = null;
+    this.connecting = null;
     this.d.mcp?.close();
-    if (!conn)
+    this.cancelAsks();
+    this.tasks.endAll("the agent stopped, and the command with it");
+    this.wakeups.endAll("the agent stopped before it woke");
+    this.endOwn("interrupted");
+    return was ? { link: was.link, spec: was.spec } : null;
+  }
+  async dropConn(why) {
+    const was = this.processGone();
+    if (!was)
       return;
-    log.info(this.d.worktreeId, `agent ${conn.spec.id} stopped: ${why} (pid ${conn.link.pid ?? "unknown"})`);
-    conn.link.conn.close();
-    await conn.link.kill();
-    this.noteProcess(conn.link, false);
+    const { link, spec } = was;
+    if (!link)
+      return log.info(this.d.worktreeId, `agent ${spec.id} stopped before it was spawned: ${why}`);
+    log.info(this.d.worktreeId, `agent ${spec.id} stopped: ${why} (pid ${link.pid ?? "unknown"})`);
+    link.conn.close();
+    await link.kill();
+    this.noteProcess(link, false);
   }
 }
+var stoppedStarting = () => new UserError("the agent was stopped while it was starting");
 function takesHttpMcp(init) {
   const http = init.agentCapabilities?.mcpCapabilities?.http;
   return http === true || typeof http === "object" && http !== null;
@@ -22373,6 +22424,23 @@ class RuntimeRegistry {
     }
     return waiting ? "waiting" : null;
   }
+  appPorts() {
+    const ports = new Set;
+    for (const wt of this.deps.state.worktrees)
+      ports.add(wt.proxyPort);
+    for (const rt of this.runtimes.values()) {
+      if (rt.proxy)
+        ports.add(rt.proxy.port);
+      for (const f of rt.forwards.values())
+        ports.add(f.port);
+      for (const st of rt.procs?.states() ?? []) {
+        ports.add(st.port);
+        if (st.boundPort !== undefined)
+          ports.add(st.boundPort);
+      }
+    }
+    return ports;
+  }
   markSetup(id, on) {
     if (on)
       this.settingUp.add(id);
@@ -24821,11 +24889,7 @@ class Knocks {
     this.hub.emit("knocksChanged");
   }
   knock(from, client = null) {
-    this.sweep();
-    const waiting = this.live.filter((k) => k.answer === null);
-    if (waiting.length >= KNOCK_MAX)
-      return null;
-    if (client !== null && waiting.filter((k) => k.client === client).length >= KNOCK_PER_CLIENT)
+    if (!this.room(client))
       return null;
     const id = randomBytes6(9).toString("base64url");
     let word = knockWord(randomInt);
@@ -24835,6 +24899,13 @@ class Knocks {
     this.changed();
     return { id, word };
   }
+  room(client) {
+    this.sweep();
+    const waiting = this.live.filter((k) => k.answer === null);
+    if (waiting.length >= KNOCK_MAX)
+      return false;
+    return client === null || waiting.filter((k) => k.client === client).length < KNOCK_PER_CLIENT;
+  }
   pending() {
     this.sweep();
     return this.live.filter((k) => k.answer === null).map(({ id, word, from }) => ({ id, word, from }));
@@ -24871,6 +24942,8 @@ class Knocks {
 var ANSWER_HOLD_MS = 30000;
 
 // ../daemon/src/core/origins.ts
+var SHELL_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]", "toyon.localhost"]);
+
 class Origins {
   d;
   constructor(d) {
@@ -24905,6 +24978,25 @@ class Origins {
       return false;
     }
   }
+  isPreview(origin) {
+    let u;
+    try {
+      u = new URL(origin);
+    } catch {
+      return true;
+    }
+    if (isLoopbackHost(u.hostname)) {
+      if (!SHELL_HOSTS.has(u.hostname))
+        return true;
+      const port = Number(u.port || (u.protocol === "https:" ? 443 : 80));
+      for (const p of this.d.appPorts())
+        if (p === port)
+          return true;
+      return false;
+    }
+    const remote = this.d.setting.get();
+    return remote !== null && (matchPreview(remote.previews, u.host) !== null || u.host === frameAuthority(remote));
+  }
 }
 
 // ../daemon/src/core/remoteSwitch.ts
@@ -25100,13 +25192,12 @@ class SelfWatch {
   async check(repo) {
     if (this.booted === null || !this.own(repo))
       return false;
-    const names = await git(this.root ?? "", "diff", "--name-only", `${this.booted}..${repo.defaultBranch}`);
+    const names = await gitRaw(this.root ?? "", "diff", "--name-only", "-z", `${this.booted}..${repo.defaultBranch}`);
     if (!names.ok) {
       log.debug("self", `could not diff ${this.booted}..${repo.defaultBranch}: ${names.err}`);
       return false;
     }
-    const paths = names.out.split(`
-`).filter((l) => l !== "");
+    const paths = nulSplit(names.out);
     const { rebuild, restart } = classify(paths);
     return this.set({ repoId: repo.id, rebuild, restart, building: this.state?.building ?? false });
   }
@@ -25235,11 +25326,19 @@ function saveState(paths, state) {
   writeFileSync9(tmp, JSON.stringify(state, null, 2));
   renameSync5(tmp, paths.stateFile);
 }
-function loadOrCreateToken(paths) {
+var TOKEN_MIN = 32;
+function loadOrCreateToken(paths, env = process.env) {
   ensureDirs(paths);
   const TOKEN_FILE = paths.tokenFile;
-  if (existsSync24(TOKEN_FILE))
-    return readFileSync14(TOKEN_FILE, "utf8").trim();
+  if (existsSync24(TOKEN_FILE)) {
+    const held = readFileSync14(TOKEN_FILE, "utf8").trim();
+    if (held.length >= TOKEN_MIN)
+      return held;
+    if (env.TOYON_CLOUD === "1") {
+      throw new Error(`${TOKEN_FILE} holds no token of ${TOKEN_MIN} characters or more; set TOYON_TOKEN to one`);
+    }
+    log.warn("state", `${TOKEN_FILE} held no usable token; a new one was written`);
+  }
   const token = randomBytes7(32).toString("hex");
   writeFileSync9(TOKEN_FILE, token, { mode: 384 });
   return token;
@@ -25643,7 +25742,7 @@ var PROBE_TIMEOUT_MS2 = 2000;
 var ANSWERED_RECENTLY_MS = 3 * 60000;
 var probe = async (origin, named) => {
   try {
-    const r = await fetch(`${origin}/health`, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS2) });
+    const r = await fetch(`${origin}/health`, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS2), redirect: "error" });
     if (!r.ok)
       return null;
     const body = await r.json();
@@ -26208,9 +26307,8 @@ class DesignService {
     const wt = this.readable(worktreeId);
     if (!wt)
       throw new UserError("unknown worktree");
-    const listed = await git(wt.path, "ls-files", "-co", "--exclude-standard");
-    const paths = listed.out.split(`
-`).filter(Boolean);
+    const listed = await gitRaw(wt.path, "ls-files", "-z", "-co", "--exclude-standard");
+    const paths = nulSplit(listed.out);
     const cssPaths = paths.filter((p) => CSS_EXT.test(p)).slice(0, MAX_CSS_FILES);
     const srcPaths = paths.filter((p) => SOURCE_EXT.test(p)).slice(0, MAX_SOURCE_FILES);
     const cssFiles = await readAll(wt.path, cssPaths);
@@ -27033,7 +27131,8 @@ function looksBinary(text) {
 
 // ../daemon/src/files/service.ts
 import { spawn as spawn5 } from "child_process";
-import { stat as stat3, unlink } from "fs/promises";
+import { lstat as lstat2, stat as stat3, unlink } from "fs/promises";
+import { join as join24 } from "path";
 
 // ../daemon/src/git/forge.ts
 function githubRepoUrl(remoteUrl) {
@@ -27150,10 +27249,9 @@ async function treeFingerprint(worktreePath) {
   const [head, diff, untracked] = await Promise.all([
     git(worktreePath, "rev-parse", "HEAD"),
     gitRaw(worktreePath, "diff", "HEAD", "--no-renames"),
-    git(worktreePath, "ls-files", "--others", "--exclude-standard")
+    gitRaw(worktreePath, "ls-files", "-z", "--others", "--exclude-standard")
   ]);
-  const others = await Promise.all(untracked.out.split(`
-`).filter(Boolean).map(async (p) => {
+  const others = await Promise.all(nulSplit(untracked.out).map(async (p) => {
     try {
       const f = Bun.file(join23(worktreePath, p));
       const body = f.size > 2000000 ? String(f.size) : Bun.hash(await f.arrayBuffer()).toString(36);
@@ -27169,7 +27267,7 @@ async function statusFiles(worktreePath, ...only) {
   return (await readStatus(worktreePath, only)).files;
 }
 async function readStatus(worktreePath, only) {
-  const args = ["status", "--porcelain", "-uall"];
+  const args = ["status", "--porcelain", "-z", "-uall"];
   const r = only.length ? await gitRaw(worktreePath, "--literal-pathspecs", ...args, "--", ...only) : await gitRaw(worktreePath, ...args);
   if (!r.ok)
     throw new Error(`git status failed: ${r.err}`);
@@ -27194,7 +27292,7 @@ function foldDropped(entries) {
   };
 }
 async function diskAgainstHead(worktreePath, file) {
-  const r = await git(worktreePath, "diff", "--numstat", "--end-of-options", `HEAD:${file}`, file);
+  const r = await gitRaw(worktreePath, "diff", "--numstat", "-z", "--end-of-options", `HEAD:${file}`, file);
   if (!r.ok)
     return {};
   if (!r.out)
@@ -27203,14 +27301,18 @@ async function diskAgainstHead(worktreePath, file) {
   return counts ?? {};
 }
 function parsePorcelain(out) {
-  const unquote = (p) => p.startsWith('"') && p.endsWith('"') ? JSON.parse(p) : p;
-  return out.split(`
-`).filter((line) => line.length > 3).map((line) => {
-    const xy = line.slice(0, 2);
-    const rest = line.slice(3);
-    const arrow = xy.includes("R") || xy.includes("C") ? rest.lastIndexOf(" -> ") : -1;
-    return { xy, path: unquote(arrow >= 0 ? rest.slice(arrow + 4) : rest) };
-  });
+  const files = [];
+  const records = out.split("\x00");
+  for (let i = 0;i < records.length; i++) {
+    const record = records[i] ?? "";
+    if (record.length <= 3)
+      continue;
+    const xy = record.slice(0, 2);
+    files.push({ xy, path: record.slice(3) });
+    if (xy.includes("R") || xy.includes("C"))
+      i++;
+  }
+  return files;
 }
 async function fileBefore(worktreePath, defaultBr, file) {
   const base = await git(worktreePath, "merge-base", "HEAD", defaultBr);
@@ -27224,18 +27326,37 @@ async function fileAt(worktreePath, commit, file) {
 }
 function parseNumstat(out) {
   const counts = new Map;
-  for (const line of out.split(`
-`)) {
-    const [a, d, ...rest] = line.split("\t");
-    const path = rest.join("\t").replace(/^"(.*)"$/, "$1");
+  const records = out.split("\x00");
+  for (let i = 0;i < records.length; i++) {
+    const [a, d, ...rest] = (records[i] ?? "").split("\t");
+    if (d === undefined)
+      continue;
+    let path = rest.join("\t");
+    if (!path) {
+      path = records[i + 2] ?? "";
+      i += 2;
+    }
     if (!path)
       continue;
     counts.set(path, a === "-" || d === "-" ? {} : { add: Number(a), del: Number(d) });
   }
   return counts;
 }
+function parseNameStatus(out) {
+  const files = [];
+  const records = out.split("\x00");
+  for (let i = 0;i + 1 < records.length; i += 2) {
+    const status = (records[i] ?? "").slice(0, 1);
+    if (status === "R" || status === "C")
+      i++;
+    const path = records[i + 1] ?? "";
+    if (status && path)
+      files.push({ status, path });
+  }
+  return files;
+}
 async function numstat(worktreePath, ...range) {
-  const r = await git(worktreePath, "diff", "--numstat", "--no-renames", ...range);
+  const r = await gitRaw(worktreePath, "diff", "--numstat", "-z", "--no-renames", ...range);
   return r.ok ? parseNumstat(r.out) : new Map;
 }
 async function untrackedLines(worktreePath, file, budget) {
@@ -27300,16 +27421,11 @@ async function committedFiles(worktreePath, defaultBr) {
   return filesBetween(worktreePath, base.out, "HEAD");
 }
 async function filesBetween(cwd, from, to) {
-  const r = await git(cwd, "diff", "--name-status", from, to);
+  const r = await gitRaw(cwd, "diff", "--name-status", "-z", from, to);
   if (!r.ok || !r.out)
     return [];
   const counts = await numstat(cwd, from, to);
-  return r.out.split(`
-`).filter(Boolean).map((line) => {
-    const [status, ...rest] = line.split("\t");
-    const path = rest[rest.length - 1] ?? "";
-    return { xy: `${(status ?? "M").slice(0, 1)} `, path, ...counts.get(path) ?? {} };
-  });
+  return parseNameStatus(r.out).map(({ status, path }) => ({ xy: `${status} `, path, ...counts.get(path) ?? {} }));
 }
 async function changedRanges(worktreePath, defaultBr, file) {
   const { files, folded } = await readStatus(worktreePath, [file]);
@@ -27360,6 +27476,11 @@ async function remoteHead(worktreePath, branch) {
 async function reaches(worktreePath, sha) {
   return (await git(worktreePath, "merge-base", "--is-ancestor", sha, "HEAD")).ok;
 }
+async function aheadOf(worktreePath, base) {
+  const r = await git(worktreePath, "rev-list", "--count", `${base}..HEAD`);
+  const n = r.ok ? Number(r.out) : Number.NaN;
+  return Number.isInteger(n) ? n : null;
+}
 async function aheadBehind(worktreePath, defaultBr) {
   const [a, b] = await Promise.all([
     git(worktreePath, "rev-list", "--count", `${defaultBr}..HEAD`),
@@ -27415,18 +27536,17 @@ async function aheadShas(worktreePath, defaultBr) {
 }
 async function commitFiles(worktreePath, sha) {
   const [names, nums] = await Promise.all([
-    git(worktreePath, "show", "--first-parent", "--name-status", "--no-renames", "--format=", sha),
-    git(worktreePath, "show", "--first-parent", "--numstat", "--no-renames", "--format=", sha)
+    gitRaw(worktreePath, "show", "--first-parent", "--name-status", "-z", "--no-renames", "--format=", sha),
+    gitRaw(worktreePath, "show", "--first-parent", "--numstat", "-z", "--no-renames", "--format=", sha)
   ]);
   if (!names.ok || !names.out)
     return [];
   const counts = nums.ok ? parseNumstat(nums.out) : new Map;
-  return names.out.split(`
-`).filter(Boolean).map((line) => {
-    const [status, ...rest] = line.split("\t");
-    const path = (rest[rest.length - 1] ?? "").replace(/^"(.*)"$/, "$1");
-    return { xy: `${(status ?? "M").slice(0, 1)} `, path, ...counts.get(path) ?? {} };
-  }).filter((f) => f.path);
+  return parseNameStatus(names.out).map(({ status, path }) => ({
+    xy: `${status} `,
+    path,
+    ...counts.get(path) ?? {}
+  }));
 }
 async function fileAtCommit(worktreePath, sha, file) {
   const [before, after] = await Promise.all([
@@ -27556,30 +27676,28 @@ function rankElementSources(el, rows) {
 // ../daemon/src/files/listing.ts
 var SUBMODULE_MODE = "160000";
 var entries3 = (out) => out.split("\x00").filter(Boolean);
-function parseListing(staged, untracked, deleted, ignored = "") {
-  const gone = new Set(entries3(deleted));
+function parseTracked(staged) {
   const paths = new Set;
   const submodules = new Set;
+  const unmerged = new Set;
   for (const line of entries3(staged)) {
     const tab = line.indexOf("\t");
     if (tab === -1)
       continue;
     const path = line.slice(tab + 1);
-    if (gone.has(path))
-      continue;
     if (line.startsWith(SUBMODULE_MODE))
       submodules.add(path);
     else
       paths.add(path);
+    if (line.charAt(tab - 1) !== "0")
+      unmerged.add(path);
   }
-  for (const path of entries3(untracked))
-    paths.add(path);
-  return { paths: [...paths], submodules: [...submodules], ignored: collapse(entries3(ignored)) };
+  return { paths: [...paths], submodules: [...submodules], unmerged: [...unmerged] };
 }
-function collapse(list) {
+function parseIgnored(ignored) {
   const out = [];
   let under = null;
-  for (const p of [...list].sort()) {
+  for (const p of entries3(ignored).sort()) {
     if (under !== null && p.startsWith(under))
       continue;
     under = p.endsWith("/") ? p : null;
@@ -27781,15 +27899,25 @@ class FileService {
       return "restored";
     });
   }
-  async list(worktreeId) {
+  async tracked(worktreeId) {
     const cwd = this.require(worktreeId).path;
-    const [staged, untracked, deleted, ignored] = await Promise.all([
+    const [staged, dropped] = await Promise.all([
       git(cwd, "ls-files", "-z", "-s"),
-      git(cwd, "ls-files", "-z", "-o", "--exclude-standard"),
-      git(cwd, "ls-files", "-z", "-d"),
-      git(cwd, "ls-files", "-z", "-o", "-i", "--exclude-standard", "--directory")
+      gitRaw(cwd, "diff", "--cached", "--name-only", "-z", "--diff-filter=D")
     ]);
-    return parseListing(staged.out, untracked.out, deleted.out, ignored.out);
+    const { paths, submodules, unmerged } = parseTracked(staged.out);
+    const there = async (list) => {
+      const found = await Promise.all(list.map((p) => lstat2(join24(cwd, p)).then(() => true, () => false)));
+      return new Set(list.filter((_, i) => found[i]));
+    };
+    const [merging, kept] = await Promise.all([there(unmerged), there(nulSplit(dropped.out))]);
+    const absent = new Set(unmerged.filter((p) => !merging.has(p)));
+    return { paths: [...absent.size > 0 ? paths.filter((p) => !absent.has(p)) : paths, ...kept], submodules };
+  }
+  async ignored(worktreeId) {
+    const cwd = this.require(worktreeId).path;
+    const ignored = await git(cwd, "ls-files", "-z", "-o", "-i", "--exclude-standard", "--directory");
+    return parseIgnored(ignored.out);
   }
   async search(worktreeId, query, asker) {
     const { path: cwd } = this.require(worktreeId);
@@ -28087,7 +28215,7 @@ async function viewPrRef(repoPath, ref) {
     if (preview)
       parsed.preview = preview;
   }
-  return { pr: { ...parsed, at: Date.now() }, head };
+  return { pr: { ...parsed, ...head ? { head } : {}, at: Date.now() }, head };
 }
 var QUEUE_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
   repository(owner: $owner, name: $name) {
@@ -28531,7 +28659,7 @@ class AfterLand {
 // ../daemon/src/repos/registry.ts
 import { existsSync as existsSync28, mkdirSync as mkdirSync8, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir10 } from "os";
-import { basename as basename9, dirname as dirname10, join as join24 } from "path";
+import { basename as basename9, dirname as dirname10, join as join25 } from "path";
 
 // ../daemon/src/git/base.ts
 async function resolveBase(repoPath, defaultBranch, route) {
@@ -28632,7 +28760,7 @@ class RepoRegistry {
       return `${repo.name} is set up now`;
     if (main.promptedAt || main.lastTurn)
       return `${repo.name} has a chat now`;
-    if (existsSync28(join24(repo.path, ".claude")))
+    if (existsSync28(join25(repo.path, ".claude")))
       return `an agent has already run in ${repo.name}`;
     if ((await statusFiles(repo.path)).length > 0 || !await treeEmpty(repo.path)) {
       return `${repo.name} has files in it now`;
@@ -28788,10 +28916,10 @@ class RepoRegistry {
       throw new UserError(current.reason);
     const was = configTarget(repo.path, !!repo.made);
     const rel = configSibling(was, kind);
-    const moved = rel !== was && existsSync28(join24(repo.path, was));
+    const moved = rel !== was && existsSync28(join25(repo.path, was));
     if (moved && !(kind === "local" && await isTracked(repo.path, was))) {
       try {
-        rmSync5(join24(repo.path, was));
+        rmSync5(join25(repo.path, was));
       } catch (e) {
         log.warn(repoId, `could not remove ${was}`, e);
       }
@@ -28800,7 +28928,7 @@ class RepoRegistry {
     }
     if (isLocalConfigFile(rel))
       await excludeFromGit(repo.path, rel);
-    const file = join24(repo.path, rel);
+    const file = join25(repo.path, rel);
     try {
       mkdirSync8(dirname10(file), { recursive: true });
       writeFileSync11(file, configText(repo.path, rel, config));
@@ -28955,7 +29083,7 @@ class RepoRegistry {
   }
   placeConfig(repo) {
     const rel = configTarget(repo.path, !!repo.made);
-    if (isLocalConfigFile(rel) && existsSync28(join24(repo.path, rel))) {
+    if (isLocalConfigFile(rel) && existsSync28(join25(repo.path, rel))) {
       fireAndForget(repo.id, excludeFromGit(repo.path, rel), "exclude local settings");
     }
     if (repo.configFile === rel)
@@ -29048,7 +29176,7 @@ class RepoRegistry {
 }
 
 // ../daemon/src/routes/service.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 
 // ../daemon/src/routes/fileRouters.ts
 var SKIP = /(^|\/)(node_modules|dist|build|out|coverage|\.next|\.nuxt|\.output|\.svelte-kit|\.vercel|\.netlify)\//;
@@ -30220,13 +30348,12 @@ class RouteService {
     return scan.inflight;
   }
   async scan(scan) {
-    const listed = await git(scan.root, "ls-files", "-co", "--exclude-standard");
+    const listed = await gitRaw(scan.root, "ls-files", "-z", "-co", "--exclude-standard");
     if (!listed.ok) {
       log.warn("routes", `could not list the files in ${scan.root}: ${listed.err}`);
       return [];
     }
-    const paths = listed.out.split(`
-`).filter(Boolean);
+    const paths = nulSplit(listed.out);
     const manifests = [];
     const keptManifests = new Map;
     for (const p of paths.filter(isManifest).slice(0, MAX_MANIFESTS)) {
@@ -30261,7 +30388,7 @@ class RouteService {
     return mergeRoutes(fileRoutes(paths, roots), code);
   }
   async cachedRead(root, path, had, kept, decode) {
-    const abs = join25(root, path);
+    const abs = join26(root, path);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -30286,7 +30413,7 @@ class RouteService {
     }
   }
   async hash(root, file) {
-    const abs = join25(root, file);
+    const abs = join26(root, file);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -30814,7 +30941,7 @@ import { homedir as homedir12, hostname as hostname2 } from "os";
 // ../daemon/src/agent/config.ts
 import { existsSync as existsSync30, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function agentConfigFiles(spec, repoPath, home = homedir11()) {
   const file = (id, label, path) => ({
     id,
@@ -30824,30 +30951,30 @@ function agentConfigFiles(spec, repoPath, home = homedir11()) {
   });
   if (spec.id === "claude") {
     return [
-      file("user-config", "user config (MCP servers, projects)", join26(home, ".claude.json")),
-      file("user-settings", "user settings (permissions, hooks)", join26(home, ".claude", "settings.json")),
-      ...repoPath ? [file("project-mcp", "project MCP servers", join26(repoPath, ".mcp.json"))] : [],
-      ...repoPath ? [file("project-settings", "project settings", join26(repoPath, ".claude", "settings.json"))] : []
+      file("user-config", "user config (MCP servers, projects)", join27(home, ".claude.json")),
+      file("user-settings", "user settings (permissions, hooks)", join27(home, ".claude", "settings.json")),
+      ...repoPath ? [file("project-mcp", "project MCP servers", join27(repoPath, ".mcp.json"))] : [],
+      ...repoPath ? [file("project-settings", "project settings", join27(repoPath, ".claude", "settings.json"))] : []
     ];
   }
   if (spec.id === "codex")
-    return [file("user-config", "config", join26(home, ".codex", "config.toml"))];
+    return [file("user-config", "config", join27(home, ".codex", "config.toml"))];
   return [];
 }
 function describeAgentConfig(spec, repoPath, home = homedir11()) {
   const files = agentConfigFiles(spec, repoPath, home);
   const servers = [];
   if (spec.id === "claude") {
-    const user = readJson(join26(home, ".claude.json"));
+    const user = readJson(join27(home, ".claude.json"));
     servers.push(...serversOf(user?.mcpServers, "user"));
     if (repoPath) {
       const projects = user?.projects;
       const mine = projects?.[repoPath];
       servers.push(...serversOf(mine?.mcpServers, "local"));
-      servers.push(...serversOf(readJson(join26(repoPath, ".mcp.json"))?.mcpServers, "project"));
+      servers.push(...serversOf(readJson(join27(repoPath, ".mcp.json"))?.mcpServers, "project"));
     }
   } else if (spec.id === "codex") {
-    servers.push(...codexServers(join26(home, ".codex", "config.toml")));
+    servers.push(...codexServers(join27(home, ".codex", "config.toml")));
   }
   return { agent: spec.id, files, servers };
 }
@@ -31677,7 +31804,11 @@ var handlers = {
       fireAndForget(msg.worktreeId, agent.warmCommands(), "warm commands");
   },
   async "list-files"(msg, ctx, s) {
-    ctx.reply({ t: "files", worktreeId: msg.worktreeId, ...await s.files.list(msg.worktreeId) });
+    const { worktreeId } = msg;
+    await Promise.all([
+      msg.tracked && s.files.tracked(worktreeId).then((l) => ctx.reply({ t: "files", worktreeId, ...l })),
+      s.files.ignored(worktreeId).then((ignored) => ctx.reply({ t: "ignored-files", worktreeId, ignored }))
+    ]);
   },
   async search(msg, ctx, s) {
     const page = await s.files.search(msg.worktreeId, msg.query, ctx.socket);
@@ -32045,7 +32176,7 @@ async function dispatch(msg, ctx, s) {
 // ../daemon/src/server/http.ts
 import { existsSync as existsSync31 } from "fs";
 import { hostname } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 
 // ../daemon/src/server/cors.ts
 var ALLOW_HEADERS = "authorization, content-type";
@@ -32118,14 +32249,20 @@ function pairingRoutes(d) {
     if (url.pathname === "/knock" && req.method === "POST") {
       const from = req.headers.get("origin");
       const own = from === null || d.origins.isOwn(from);
-      const placed = front || from !== null && d.origins.isLoopback(from);
-      if (!own && (!isShellOrigin(from) || !placed || !await d.tailnet.isToyon(from))) {
-        return new Response("not a Toyon page", { status: 403 });
+      const client = door.kind === "shell" ? door.client : null;
+      const full = () => new Response("too many devices are waiting to be let in", { status: 429 });
+      if (!own) {
+        const placed = front || d.origins.isLoopback(from);
+        if (!isShellOrigin(from) || !placed || d.origins.isPreview(from)) {
+          return new Response("not a Toyon page", { status: 403 });
+        }
+        if (!d.knocks.room(client))
+          return full();
+        if (!await d.tailnet.isToyon(from))
+          return new Response("not a Toyon page", { status: 403 });
       }
-      const knocked = d.knocks.knock(own ? null : from, door.kind === "shell" ? door.client : null);
-      if (!knocked)
-        return new Response("too many devices are waiting to be let in", { status: 429 });
-      return json(knocked);
+      const knocked = d.knocks.knock(own ? null : from, client);
+      return knocked ? json(knocked) : full();
     }
     const polled = knockPolled(url);
     if (polled !== null && req.method === "GET") {
@@ -32235,6 +32372,11 @@ function attachedHeaders(imageType) {
     ...imageType ? {} : { "content-security-policy": "sandbox" }
   };
 }
+var DRAWN_HEADERS = {
+  "cache-control": NO_STORE2,
+  "x-content-type-options": "nosniff",
+  "content-security-policy": "sandbox"
+};
 function createFetch(opts) {
   const grant = previewGrant(opts.token);
   const authed = (req) => sameSecret(req.headers.get("authorization"), `Bearer ${opts.token}`);
@@ -32526,7 +32668,7 @@ function createFetch(opts) {
       if (!path)
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), {
-        headers: { "cache-control": NO_STORE2, "x-content-type-options": "nosniff" }
+        headers: DRAWN_HEADERS
       });
     }
     if (url.pathname.startsWith("/loose/")) {
@@ -32536,11 +32678,11 @@ function createFetch(opts) {
       if (!path)
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), {
-        headers: { "cache-control": NO_STORE2, "x-content-type-options": "nosniff" }
+        headers: DRAWN_HEADERS
       });
     }
     const rel = url.pathname === "/" ? "/index.html" : url.pathname;
-    const file = join27(opts.shellDist, rel.replaceAll("..", ""));
+    const file = join28(opts.shellDist, rel.replaceAll("..", ""));
     const hashed = rel.startsWith("/assets/");
     if (existsSync31(file) && Bun.file(file).size > 0) {
       if (rel === "/manifest.json") {
@@ -32574,7 +32716,7 @@ function createFetch(opts) {
     }
     if (hashed)
       return new Response("not found", { status: 404 });
-    const index = join27(opts.shellDist, "index.html");
+    const index = join28(opts.shellDist, "index.html");
     if (existsSync31(index))
       return page(req, index);
     return new Response("Toyon daemon running; shell not built (run: bun run build)", { status: 200 });
@@ -33129,14 +33271,14 @@ function startServer(opts) {
 // ../daemon/src/themes/store.ts
 import { existsSync as existsSync32, readdirSync as readdirSync8, readFileSync as readFileSync18, statSync as statSync11, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir13 } from "os";
-import { basename as basename10, dirname as dirname11, join as join28, resolve as resolve11 } from "path";
+import { basename as basename10, dirname as dirname11, join as join29, resolve as resolve11 } from "path";
 var home = homedir13();
 var defaultExtensionDirs = [
-  join28(home, ".vscode", "extensions"),
-  join28(home, ".vscode-insiders", "extensions"),
-  join28(home, ".vscode-oss", "extensions"),
-  join28(home, ".cursor", "extensions"),
-  join28(home, ".windsurf", "extensions"),
+  join29(home, ".vscode", "extensions"),
+  join29(home, ".vscode-insiders", "extensions"),
+  join29(home, ".vscode-oss", "extensions"),
+  join29(home, ".cursor", "extensions"),
+  join29(home, ".windsurf", "extensions"),
   "/Applications/Visual Studio Code.app/Contents/Resources/app/extensions",
   "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions",
   "/Applications/Cursor.app/Contents/Resources/app/extensions",
@@ -33220,7 +33362,7 @@ class ThemeStore {
       name: json?.name ?? base,
       source: "file"
     });
-    writeFileSync12(join28(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
+    writeFileSync12(join29(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
 `);
     this.load();
     return theme;
@@ -33255,7 +33397,7 @@ function loadDir(dir) {
   for (const f of readdirSync8(dir)) {
     if (!/\.jsonc?$/i.test(f))
       continue;
-    const file = join28(dir, f);
+    const file = join29(dir, f);
     const id = `file:${slug(f.replace(/\.(json|jsonc)$/i, ""))}`;
     try {
       const json = readJsonc(file);
@@ -33281,8 +33423,8 @@ function discover(dir) {
     return out;
   }
   for (const name of entries) {
-    const extDir = join28(dir, name);
-    const pkgFile = join28(extDir, "package.json");
+    const extDir = join29(dir, name);
+    const pkgFile = join29(extDir, "package.json");
     try {
       if (!statSync11(extDir).isDirectory() || !existsSync32(pkgFile))
         continue;
@@ -33292,7 +33434,7 @@ function discover(dir) {
         continue;
       const ext = `${pkg.publisher ?? "local"}.${pkg.name ?? name}`;
       let nls = {};
-      const nlsFile = join28(extDir, "package.nls.json");
+      const nlsFile = join29(extDir, "package.nls.json");
       if (existsSync32(nlsFile)) {
         try {
           nls = JSON.parse(readFileSync18(nlsFile, "utf8"));
@@ -33782,7 +33924,7 @@ class BackendShare {
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync33, readFileSync as readFileSync19 } from "fs";
 import { mkdir as mkdir5, readdir as readdir2, rename, rm as rm5, stat as stat5, utimes, writeFile as writeFile3 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // ../daemon/src/core/clone.ts
 import { mkdir as mkdir4, rm as rm4 } from "fs/promises";
@@ -33813,7 +33955,7 @@ var STALE_MS = 30 * 24 * 3600000;
 var TMP = ".tmp-";
 var MANIFEST = "manifest.json";
 function defaultTools(dir) {
-  const has = (...files) => files.some((f) => existsSync33(join29(dir, f)));
+  const has = (...files) => files.some((f) => existsSync33(join30(dir, f)));
   const out = [];
   if (has("bun.lock", "bun.lockb"))
     out.push("bun --version");
@@ -33826,7 +33968,7 @@ function defaultTools(dir) {
   return out;
 }
 function withSidecars(root, rel) {
-  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync33(join29(root, n)));
+  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync33(join30(root, n)));
 }
 var entryName = (base, at) => `${base.slice(0, 12)}-${at.toString(36)}`;
 async function listEntries(familyDir) {
@@ -33841,8 +33983,8 @@ async function listEntries(familyDir) {
     const m = /^([0-9a-f]{12})-([0-9a-z]+)$/.exec(name);
     if (!m?.[1] || !m[2])
       continue;
-    const dir = join29(familyDir, name);
-    if (!existsSync33(join29(dir, MANIFEST)))
+    const dir = join30(familyDir, name);
+    if (!existsSync33(join30(dir, MANIFEST)))
       continue;
     out.push({ dir, base: m[1], at: Number.parseInt(m[2], 36) });
   }
@@ -33872,7 +34014,7 @@ class ArtifactCache {
     try {
       const family = await this.family(wt, repo, policy);
       const base = await this.baseCommit(wt, repo);
-      const entries = await listEntries(join29(this.d.paths.cacheDir, repo.id, family.key));
+      const entries = await listEntries(join30(this.d.paths.cacheDir, repo.id, family.key));
       const entry = entries.find((e) => e.base === base.slice(0, 12)) ?? entries[0];
       if (!entry) {
         say(`cache: nothing kept for these lockfiles and tools on ${family.platform}`);
@@ -33880,14 +34022,14 @@ class ArtifactCache {
       }
       const restored = [];
       for (const rel of policy.paths) {
-        if (existsSync33(join29(wt.path, rel)))
+        if (existsSync33(join30(wt.path, rel)))
           continue;
         const names = withSidecars(entry.dir, rel);
         if (names.length === 0)
           continue;
         let whole = true;
         for (const name of names) {
-          const r = await (this.d.clone ?? cloneTree)(join29(entry.dir, name), join29(wt.path, name));
+          const r = await (this.d.clone ?? cloneTree)(join30(entry.dir, name), join30(wt.path, name));
           if (r.ok)
             continue;
           say(`cache: could not restore ${name}: ${r.error}`);
@@ -33921,12 +34063,12 @@ class ArtifactCache {
     let tmp;
     let slot;
     try {
-      const present = policy.paths.filter((rel) => existsSync33(join29(wt.path, rel)));
+      const present = policy.paths.filter((rel) => existsSync33(join30(wt.path, rel)));
       if (present.length === 0)
         return;
       const family = await this.family(wt, repo, policy);
       const base = await this.baseCommit(wt, repo);
-      const familyDir = join29(this.d.paths.cacheDir, repo.id, family.key);
+      const familyDir = join30(this.d.paths.cacheDir, repo.id, family.key);
       const key = `${familyDir}/${base.slice(0, 12)}`;
       const kept = (await listEntries(familyDir)).find((e) => e.base === base.slice(0, 12));
       if (kept || this.making.has(key)) {
@@ -33937,21 +34079,21 @@ class ArtifactCache {
       this.making.add(key);
       const at = Date.now();
       const name = entryName(base, at);
-      tmp = join29(familyDir, `${TMP}${name}`);
+      tmp = join30(familyDir, `${TMP}${name}`);
       await mkdir5(tmp, { recursive: true });
       let how = "clonefile";
       for (const rel of present) {
         for (const n of withSidecars(wt.path, rel)) {
-          const r = await (this.d.clone ?? cloneTree)(join29(wt.path, n), join29(tmp, n));
+          const r = await (this.d.clone ?? cloneTree)(join30(wt.path, n), join30(tmp, n));
           if (!r.ok)
             throw new Error(`could not keep ${n}: ${r.error}`);
           how = r.how;
         }
       }
       const manifest = { at, base, platform: family.platform, tools: family.tools, paths: present };
-      await writeFile3(join29(tmp, MANIFEST), `${JSON.stringify(manifest, null, 2)}
+      await writeFile3(join30(tmp, MANIFEST), `${JSON.stringify(manifest, null, 2)}
 `);
-      await rename(tmp, join29(familyDir, name));
+      await rename(tmp, join30(familyDir, name));
       tmp = undefined;
       log.info(worktreeId, `cache: kept ${list(present)} for ${base.slice(0, 7)} via ${how} in ${Date.now() - started}ms`);
       await this.prune(familyDir);
@@ -33979,7 +34121,7 @@ class ArtifactCache {
       return;
     }
     for (const repoId of repoIds) {
-      const repoDir = join29(root, repoId);
+      const repoDir = join30(root, repoId);
       if (!this.d.state.repo(repoId)) {
         await rm5(repoDir, { recursive: true, force: true });
         continue;
@@ -33991,7 +34133,7 @@ class ArtifactCache {
         continue;
       }
       for (const family of families) {
-        const familyDir = join29(repoDir, family);
+        const familyDir = join30(repoDir, family);
         let names;
         try {
           names = await readdir2(familyDir);
@@ -34000,7 +34142,7 @@ class ArtifactCache {
         }
         for (const n of names)
           if (n.startsWith(TMP))
-            await rm5(join29(familyDir, n), { recursive: true, force: true });
+            await rm5(join30(familyDir, n), { recursive: true, force: true });
         const entries = await listEntries(familyDir);
         let newest = 0;
         for (const e of entries) {
@@ -34020,7 +34162,7 @@ class ArtifactCache {
     for (const f of policy.key) {
       h.update(`\x00${f}\x00`);
       try {
-        h.update(readFileSync19(join29(wt.path, f)));
+        h.update(readFileSync19(join30(wt.path, f)));
       } catch {
         h.update("(absent)");
       }
@@ -34337,7 +34479,7 @@ class FixService {
 // ../daemon/src/worktrees/handoff.ts
 import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
 import { readFileSync as readFileSync20 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // ../daemon/src/worktrees/proposals.ts
 var PER_TURN_MAX = 3;
@@ -34853,9 +34995,9 @@ class HandoffService {
     if (go)
       await this.act(worktreeId, id, note?.trim() || undefined);
     else
-      await this.decline(worktreeId, id);
+      await this.decline(worktreeId, id, undefined, note?.trim() || undefined);
   }
-  async decline(worktreeId, id, reason) {
+  async decline(worktreeId, id, reason, note) {
     const wt = this.d.state.worktree(worktreeId);
     if (!wt)
       return;
@@ -34869,9 +35011,17 @@ class HandoffService {
       type: "handoff-declined",
       id,
       ...reason ? { outcome: "failed", reason } : {},
+      ...note ? { note } : {},
       ...plan ? { plan } : {},
       ts: Date.now()
     });
+    if (!note)
+      return;
+    const text = handoffDeclinedPrompt(proposed.pieces, note);
+    fireAndForget(wt.id, this.idle(wt.id, agent).then(() => agent.send(text, {
+      asked: { kind: "handoff", why: "the list was sent back with a note, so the agent reads it before going on" },
+      keepCards: true
+    })), "pieces declined");
   }
   async act(worktreeId, id, note, tell = false) {
     const wt = this.d.state.worktree(worktreeId);
@@ -35003,7 +35153,7 @@ ${p.section}`;
       return;
     let markdown;
     try {
-      markdown = readFileSync20(join30(wt.path, card.plan), "utf8");
+      markdown = readFileSync20(join31(wt.path, card.plan), "utf8");
     } catch (e) {
       log.warn(worktreeId, `could not read ${card.plan} to see whether the plan moved`, e);
       return;
@@ -35626,6 +35776,32 @@ class LandingService {
       return;
     fireAndForget(worktreeId, this.run(wt, { at: Date.now(), ask: false, quiet: true }), "landing recheck");
   }
+  async message(worktreeId) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt || !this.d.judge)
+      return;
+    const repo = this.d.state.requireRepo(wt.repoId);
+    let verdict = null;
+    try {
+      verdict = await this.d.judge(wt, landPrompt(await this.landInput(wt, repo)));
+    } catch (e) {
+      log.warn(worktreeId, "landing message unanswered at the press", e);
+    }
+    if (!verdict?.subject)
+      return;
+    const now = this.d.state.worktree(worktreeId)?.landing;
+    if (now && !now.subject) {
+      const { unanswered: _owed, ...rest } = now;
+      this.d.worktrees.setLanding(worktreeId, {
+        ...rest,
+        subject: verdict.subject,
+        ...verdict.body ? { body: verdict.body } : {}
+      });
+    }
+    return verdict.body ? `${verdict.subject}
+
+${verdict.body}` : verdict.subject;
+  }
   async landInput(wt, repo) {
     const base = baseOf(repo);
     const entries = this.d.transcript(wt.id);
@@ -35793,15 +35969,16 @@ function tail(text) {
   const t = text.replace(/\s+$/, "");
   return t.length > TAIL_CHARS ? t.slice(-TAIL_CHARS) : t;
 }
+var PLAIN_NAMES = ["-c", "core.quotePath=false"];
 async function diffSummary(id, path, defaultBr) {
   const [base, dirty, untracked] = await Promise.all([
     git(path, "merge-base", "HEAD", defaultBr),
-    git(path, "diff", "HEAD", "--stat"),
-    git(path, "ls-files", "--others", "--exclude-standard")
+    git(path, ...PLAIN_NAMES, "diff", "HEAD", "--stat"),
+    git(path, ...PLAIN_NAMES, "ls-files", "--others", "--exclude-standard")
   ]);
   if (!base.ok)
     log.warn(id, `landing question: no merge base with ${defaultBr}: ${base.err.trim()}`);
-  const committed = base.ok && base.out ? await git(path, "diff", "--stat", base.out, "HEAD") : null;
+  const committed = base.ok && base.out ? await git(path, ...PLAIN_NAMES, "diff", "--stat", base.out, "HEAD") : null;
   const own = [dirty.out ? `Uncommitted:
 ${dirty.out}` : "", untracked.out ? `New files:
 ${untracked.out}` : ""].filter(Boolean).join(`
@@ -36022,14 +36199,28 @@ function parseWorktreeList(out) {
     entries.push(cur);
   return entries;
 }
+var C_ESCAPES = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13 };
 function unquote(s) {
-  if (!s.startsWith('"') || !s.endsWith('"'))
-    return s;
-  try {
-    return JSON.parse(s);
-  } catch {
+  if (s.length < 2 || !s.startsWith('"') || !s.endsWith('"'))
     return s;
+  const bytes = [];
+  const body = Buffer.from(s.slice(1, -1), "utf8");
+  for (let i = 0;i < body.length; i++) {
+    const b = body[i];
+    if (b !== 92) {
+      bytes.push(b);
+      continue;
+    }
+    const octal = /^[0-3][0-7]{2}/.exec(body.subarray(i + 1, i + 4).toString("latin1"));
+    if (octal) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      i += 3;
+      continue;
+    }
+    const next = String.fromCharCode(body[++i] ?? 92);
+    bytes.push(C_ESCAPES[next] ?? next.charCodeAt(0));
   }
+  return Buffer.from(bytes).toString("utf8");
 }
 async function listWorktrees(repoPath) {
   const r = await git(repoPath, "worktree", "list", "--porcelain");
@@ -36267,6 +36458,11 @@ class PrService {
     this.d = d;
     d.hub.on("repoTick", (repoId) => this.refreshRepo(repoId));
     d.hub.on("turnSettled", (id) => fireAndForget(id, this.discover(id, "turn"), "pr discovery"));
+    d.hub.on("prDue", (id) => {
+      const wt = this.d.state.worktree(id);
+      if (wt)
+        this.ask(wt);
+    });
     this.timer = setInterval(() => this.refreshAll(), d.everyMs ?? POLL_MS3);
     this.timer.unref?.();
     this.fast = setInterval(() => this.refreshHeld(), d.fastMs ?? FAST_MS);
@@ -36298,11 +36494,15 @@ class PrService {
         continue;
       if (!wt.pr)
         fireAndForget(wt.id, this.discover(wt.id, why), "pr discovery");
-      else if (wt.pr.state === "open")
-        fireAndForget(wt.id, this.refresh(wt.id), "pr refresh");
-      else if (wt.pr.state === "merged" && !prTaken(wt)) {
-        fireAndForget(wt.id, this.d.worktrees.prMerged(wt.id), "pr landing");
-      }
+      else
+        this.ask(wt);
+    }
+  }
+  ask(wt) {
+    if (wt.pr?.state === "open")
+      fireAndForget(wt.id, this.refresh(wt.id), "pr refresh");
+    else if (wt.pr?.state === "merged" && !prTaken(wt)) {
+      fireAndForget(wt.id, this.d.worktrees.prMerged(wt.id), "pr landing");
     }
   }
   async discover(worktreeId, why) {
@@ -36643,7 +36843,7 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 // ../daemon/src/worktrees/service.ts
 import { cpSync, existsSync as existsSync38, readFileSync as readFileSync22, rmSync as rmSync9 } from "fs";
 import { rm as rm6 } from "fs/promises";
-import { dirname as dirname15, join as join35 } from "path";
+import { dirname as dirname15, join as join36 } from "path";
 
 // ../daemon/src/git/archive.ts
 import { rmSync as rmSync6 } from "fs";
@@ -36654,7 +36854,7 @@ async function keepState(repoPath, wtPath, ref, indexFile) {
   const head = await git(wtPath, "rev-parse", "--verify", "HEAD");
   if (!head.ok)
     return null;
-  const status = await gitRaw(wtPath, "status", "--porcelain", "-uall");
+  const status = await gitRaw(wtPath, "status", "--porcelain", "-z", "-uall");
   const files = status.ok ? parsePorcelain(status.out).length : null;
   const dirty = files === null || files > 0;
   const snapshot = dirty ? await snapshotCommit(wtPath, head.out, indexFile) : null;
@@ -36703,9 +36903,8 @@ async function keptAt(repoPath, ref) {
   const snapshot = subject === SNAPSHOT_SUBJECT && author === SNAPSHOT_AUTHOR && parents && !parents.includes(" ");
   if (!snapshot)
     return { head: commit };
-  const files = await git(repoPath, "diff", "--name-only", parents, commit);
-  const dirty = files.ok ? files.out.split(`
-`).filter(Boolean).length : 0;
+  const files = await gitRaw(repoPath, "diff", "--name-only", "-z", parents, commit);
+  const dirty = files.ok ? nulSplit(files.out).length : 0;
   return { head: parents, snapshot: commit, ...dirty ? { dirty } : {} };
 }
 async function checkOutKept(repoPath, wtPath, kept, branch) {
@@ -36766,8 +36965,357 @@ async function dropLandRefs(repoPath, worktreeId) {
     await git(repoPath, "update-ref", "-d", ref);
 }
 
+// ../daemon/src/git/turn.ts
+import { copyFileSync, existsSync as existsSync34, rmSync as rmSync7 } from "fs";
+import { join as join32 } from "path";
+var turnRef = (worktreeId, which) => `refs/toyon/turns/${worktreeId}/${which}`;
+var SNAPSHOT_SUBJECT2 = "toyon: tree at a send";
+var queue = new Map;
+function inTurn(wtPath, job) {
+  const next = (queue.get(wtPath) ?? Promise.resolve()).then(job, job);
+  queue.set(wtPath, next.catch(() => {}));
+  return next;
+}
+var synced = new Map;
+var MAX_PATHS = 400;
+async function treeNow(wtPath, head, dirty) {
+  let was = synced.get(wtPath);
+  let index = was?.index;
+  if (!index) {
+    const dir = await git(wtPath, "rev-parse", "--absolute-git-dir");
+    if (!dir.ok || !dir.out)
+      return null;
+    index = join32(dir.out, "toyon-turn-index");
+  }
+  const env = { GIT_INDEX_FILE: index };
+  const writeTree = async () => {
+    const tree = await run(GIT, ["write-tree"], wtPath, env);
+    return tree.ok && tree.out ? tree.out : null;
+  };
+  if (!existsSync34(index))
+    was = undefined;
+  const paths = dirty && !dirty.some((f) => /[RC]/.test(f.xy)) ? dirty.map((f) => f.path) : null;
+  if (was && paths && was.head === head) {
+    const again = [...new Set([...was.dirty, ...paths])];
+    if (again.length <= MAX_PATHS) {
+      const added = again.length === 0 || (await run(GIT, ["--literal-pathspecs", "add", "-A", "--", ...again], wtPath, env)).ok;
+      const tree = added ? await writeTree() : null;
+      if (tree) {
+        synced.set(wtPath, { index, head, dirty: new Set(paths) });
+        return tree;
+      }
+    }
+  }
+  synced.delete(wtPath);
+  if (!existsSync34(index)) {
+    const own = join32(index, "..", "index");
+    if (existsSync34(own))
+      copyFileSync(own, index);
+    else if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
+      return null;
+  }
+  const full = async () => (await run(GIT, ["add", "-A"], wtPath, env)).ok ? writeTree() : null;
+  let tree = await full();
+  if (!tree) {
+    rmSync7(index, { force: true });
+    if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
+      return null;
+    tree = await full();
+    if (!tree)
+      return null;
+  }
+  const differs = await gitRaw(wtPath, "diff", "--name-only", "--no-renames", "-z", head, tree);
+  if (differs.ok)
+    synced.set(wtPath, { index, head, dirty: new Set(nulSplit(differs.out)) });
+  return tree;
+}
+async function snapshotAt(wtPath, ref) {
+  const r = await git(wtPath, "rev-parse", "--quiet", `${ref}^{commit}`, `${ref}^{tree}`, `${ref}^`);
+  const [commit, tree, parent] = r.ok ? r.out.split(`
+`) : [];
+  return commit && tree && parent ? { commit, tree, parent } : null;
+}
+function markTurn(wtPath, worktreeId) {
+  return inTurn(wtPath, async () => {
+    const head = await git(wtPath, "rev-parse", "--verify", "HEAD");
+    if (!head.ok)
+      return;
+    const tree = await treeNow(wtPath, head.out);
+    if (!tree)
+      return;
+    const at = await snapshotAt(wtPath, turnRef(worktreeId, "at"));
+    if (at?.tree === tree && at.parent === head.out)
+      return;
+    const commit = await git(wtPath, "-c", "user.name=toyon", "-c", "user.email=toyon@localhost", "commit-tree", tree, "-p", head.out, "-m", SNAPSHOT_SUBJECT2);
+    if (!commit.ok)
+      return;
+    if (at && at.tree !== tree)
+      await git(wtPath, "update-ref", turnRef(worktreeId, "before"), at.commit);
+    await git(wtPath, "update-ref", turnRef(worktreeId, "at"), commit.out);
+  });
+}
+function turnChanges(wtPath, worktreeId, defaultBr, own, dirty) {
+  return inTurn(wtPath, async () => {
+    const at = await snapshotAt(wtPath, turnRef(worktreeId, "at"));
+    if (!at)
+      return null;
+    const head = await git(wtPath, "rev-parse", "HEAD", "HEAD^{tree}");
+    const [headCommit, headTree] = head.ok ? head.out.split(`
+`) : [];
+    if (!headCommit)
+      return null;
+    const tree = await treeNow(wtPath, headCommit, dirty);
+    if (!tree)
+      return null;
+    const from = at.tree !== tree ? at : await snapshotAt(wtPath, turnRef(worktreeId, "before"));
+    if (!from || from.tree === tree || from.tree === headTree)
+      return null;
+    if (from.parent !== headCommit) {
+      if (!own)
+        return null;
+      const [then, now] = await Promise.all([
+        git(wtPath, "merge-base", from.parent, defaultBr),
+        git(wtPath, "merge-base", headCommit, defaultBr)
+      ]);
+      if (!then.ok || !now.ok || then.out !== now.out)
+        return null;
+    }
+    const files = await filesBetween(wtPath, from.commit, tree);
+    return files.length > 0 ? { base: from.commit, files } : null;
+  });
+}
+async function dropTurnRefs(repoPath, worktreeId) {
+  for (const which of ["at", "before"])
+    await git(repoPath, "update-ref", "-d", turnRef(worktreeId, which));
+}
+
+// ../daemon/src/worktrees/archive.ts
+import { existsSync as existsSync35, mkdirSync as mkdirSync9, readdirSync as readdirSync9, readFileSync as readFileSync21, renameSync as renameSync7, rmSync as rmSync8, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename13, dirname as dirname14, join as join33 } from "path";
+class WorktreeArchive {
+  dir;
+  records = new Map;
+  constructor(dir) {
+    this.dir = dir;
+    mkdirSync9(dir, { recursive: true });
+    for (const id of readdirSync9(dir)) {
+      const file = this.filesOf(id).record;
+      if (!existsSync35(file))
+        continue;
+      try {
+        this.records.set(id, JSON.parse(readFileSync21(file, "utf8")));
+      } catch (e) {
+        log.warn("archive", `skipped an unreadable record: ${file}`, e);
+      }
+    }
+  }
+  get(id) {
+    return this.records.get(id);
+  }
+  put(rec, from) {
+    const at = this.filesOf(rec.worktree.id);
+    mkdirSync9(at.dir, { recursive: true });
+    move(from.transcript, at.transcript);
+    move(from.attachments, at.attachments);
+    move(from.plans, at.plans);
+    writeFileSync13(at.record, JSON.stringify(rec, null, 2));
+    this.records.set(rec.worktree.id, rec);
+    return { transcript: at.transcript, attachments: at.attachments, plans: at.plans };
+  }
+  take(id, to) {
+    if (!this.records.has(id))
+      return;
+    const at = this.filesOf(id);
+    move(at.transcript, to.transcript);
+    move(at.attachments, to.attachments);
+    move(at.plans, to.plans);
+    this.delete(id);
+  }
+  delete(id) {
+    if (!this.records.has(id))
+      return;
+    rmSync8(this.filesOf(id).dir, { recursive: true, force: true });
+    this.records.delete(id);
+  }
+  list(repo) {
+    return this.recordsOf(repo).sort((a, b) => b.archivedAt - a.archivedAt).map((r) => summarize(r, repo.id, this.filesOf(r.worktree.id).transcript));
+  }
+  recordsOf(repo) {
+    return [...this.records.values()].filter((r) => r.worktree.repoId === repo.id || r.repoPath === repo.path);
+  }
+  save(id) {
+    const rec = this.records.get(id);
+    if (!rec)
+      return;
+    writeFileSync13(this.filesOf(id).record, JSON.stringify(rec, null, 2));
+  }
+  chatFiles(id) {
+    if (!this.records.has(id))
+      return;
+    const at = this.filesOf(id);
+    return { transcript: at.transcript, attachments: at.attachments, plans: at.plans };
+  }
+  planFile(id, rel) {
+    if (!this.records.has(id) || !isPlanPath(rel))
+      return null;
+    const file = join33(this.filesOf(id).plans, basename13(rel));
+    if (!existsSync35(file))
+      return null;
+    try {
+      return readFileSync21(file, "utf8");
+    } catch (e) {
+      log.warn(id, `could not read its archived plan ${rel}`, e);
+      return null;
+    }
+  }
+  filesOf(id) {
+    const dir = join33(this.dir, id);
+    return {
+      dir,
+      record: join33(dir, "record.json"),
+      transcript: join33(dir, "transcript.jsonl"),
+      attachments: join33(dir, "attachments"),
+      plans: join33(dir, "plans")
+    };
+  }
+}
+function summarize(r, repoId, transcript) {
+  return {
+    id: r.worktree.id,
+    repoId,
+    title: r.worktree.title,
+    branch: r.worktree.branch,
+    path: r.worktree.path,
+    createdAt: r.worktree.createdAt,
+    archivedAt: r.archivedAt,
+    ...r.prompt ? { prompt: r.prompt } : {},
+    restorable: !!r.kept,
+    transcript,
+    ...r.sessionId ? { sessionId: r.sessionId } : {},
+    ...r.kept?.snapshot ? { uncommitted: true, ...r.kept.dirty ? { dirty: r.kept.dirty } : {} } : {},
+    ...r.worktree.landed ? { landed: true } : {},
+    ...r.worktree.lands?.length ? { lands: r.worktree.lands } : {},
+    ...r.cost !== undefined ? { cost: r.cost } : {},
+    ...r.auto ? { auto: r.auto } : {}
+  };
+}
+function lastUsage(transcript) {
+  if (!existsSync35(transcript))
+    return null;
+  const lines = readFileSync21(transcript, "utf8").split(`
+`);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    if (!lines[i]?.includes('"usage"'))
+      continue;
+    try {
+      const e = JSON.parse(lines[i]).event;
+      if (e?.type === "usage")
+        return { used: e.used, size: e.size, ...e.cost !== undefined ? { cost: e.cost } : {} };
+    } catch {}
+  }
+  return null;
+}
+function firstPrompt(transcript) {
+  if (!existsSync35(transcript))
+    return;
+  for (const line of readFileSync21(transcript, "utf8").split(`
+`)) {
+    if (!line.includes('"user-message"') && !line.includes('"handed"'))
+      continue;
+    try {
+      const event = JSON.parse(line).event;
+      if (event?.type === "user-message")
+        return event.text.slice(0, 500);
+      if (event?.type === "handed")
+        return (event.body ?? event.text).slice(0, 500);
+    } catch {}
+  }
+  return;
+}
+function move(from, to) {
+  if (!existsSync35(from))
+    return;
+  mkdirSync9(dirname14(to), { recursive: true });
+  rmSync8(to, { recursive: true, force: true });
+  renameSync7(from, to);
+}
+
+// ../daemon/src/worktrees/archivedGit.ts
+class ArchivedGit {
+  repoPath;
+  kept;
+  lands;
+  defaultBr;
+  constructor(repoPath, kept, lands, defaultBr) {
+    this.repoPath = repoPath;
+    this.kept = kept;
+    this.lands = lands;
+    this.defaultBr = defaultBr;
+  }
+  async tailBase() {
+    const r = await git(this.repoPath, "merge-base", this.kept.head, this.defaultBr);
+    return r.ok && r.out ? r.out : this.kept.head;
+  }
+  async status() {
+    const base = await this.tailBase();
+    const { head, snapshot } = this.kept;
+    const [files, committed] = await Promise.all([
+      snapshot ? filesBetween(this.repoPath, head, snapshot) : [],
+      base === head ? [] : filesBetween(this.repoPath, base, head)
+    ]);
+    return { files, committed, head: snapshot ?? head };
+  }
+  async log() {
+    const seen = new Set;
+    const unseen = (list) => {
+      const out = list.filter((c) => !seen.has(c.sha));
+      for (const c of out)
+        seen.add(c.sha);
+      return out;
+    };
+    const landed = [];
+    for (const land of this.lands) {
+      const commits = unseen(await logRange(this.repoPath, land.base, land.tip));
+      landed.push(commits.map((c) => ({ ...c, landedAt: land.at })));
+    }
+    const base = await this.tailBase();
+    const tail = base === this.kept.head ? [] : unseen(await logRange(this.repoPath, base, this.kept.head));
+    return [...tail, ...landed.reverse().flat()];
+  }
+  commitFiles(sha) {
+    return commitFiles(this.repoPath, sha);
+  }
+  async file(path, ref) {
+    if (ref)
+      return fileAtCommit(this.repoPath, ref, path);
+    const base = await this.tailBase();
+    const [before, after] = await Promise.all([
+      gitRaw(this.repoPath, "show", `${base}:${path}`),
+      gitRaw(this.repoPath, "show", `${this.kept.snapshot ?? this.kept.head}:${path}`)
+    ]);
+    return { before: before.ok ? before.out : "", after: after.ok ? after.out : "" };
+  }
+}
+
+// ../daemon/src/worktrees/landSubjects.ts
+function unfilled(mark) {
+  return mark.subjects === undefined;
+}
+async function fillLandMarks(jobs, read, width = 8) {
+  let next = 0;
+  const worker = async () => {
+    while (next < jobs.length) {
+      const job = jobs[next++];
+      if (!job)
+        return;
+      job.mark.subjects = await read(job.cwd, job.mark) ?? [];
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(width, jobs.length) }, worker));
+}
+
 // ../daemon/src/git/land.ts
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 var STEP_TIMEOUT_MS = RUN_CEILING_MS;
 function rowOf(r) {
   return r.shown && r.toolId && r.command ? { toolId: r.toolId, command: r.command, text: r.text } : undefined;
@@ -36864,9 +37412,8 @@ async function putBack(worktreePath, defaultBr, how, aside, taken) {
       await git(worktreePath, "update-ref", "-d", CARRIED);
       return taken;
     }
-    const unmerged = await git(worktreePath, "diff", "--name-only", "--diff-filter=U");
-    clash = unmerged.out.split(`
-`).filter(Boolean);
+    const unmerged = await gitRaw(worktreePath, "diff", "--name-only", "-z", "--diff-filter=U");
+    clash = nulSplit(unmerged.out);
     await git(worktreePath, "reset", "--hard", "-q", aside.head);
   }
   const back = await git(worktreePath, "stash", "apply", "--index", aside.sha);
@@ -36901,7 +37448,7 @@ async function midway(worktreePath) {
   if (!r.ok)
     return null;
   const at = r.out.split(`
-`).findIndex((file) => file && existsSync34(file));
+`).findIndex((file) => file && existsSync36(file));
   return MIDWAY[at]?.[1] ?? null;
 }
 async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = false) {
@@ -37136,8 +37683,9 @@ async function pushLanding(worktreePath, sha, defaultBr, w = UNWATCHED) {
 }
 async function mergeFailure(cwd, m, conflictMessage) {
   const conflict = /CONFLICT|Automatic merge failed/.test(m.text);
-  if (conflict) {
+  if (conflict || await midway(cwd) === "merge")
     await git(cwd, "merge", "--abort");
+  if (conflict) {
     const step = rowOf(m);
     return {
       ok: false,
@@ -37146,6 +37694,8 @@ async function mergeFailure(cwd, m, conflictMessage) {
       message: m.shown ? `${conflictMessage}; the conflicts are on the chat` : `${conflictMessage} (${m.text.slice(0, 200)})`
     };
   }
+  if (m.hook)
+    return stepRefused("merge refused", m);
   return {
     ok: false,
     message: m.shown ? "merge failed: what git printed is on the chat" : `merge failed: ${m.text.slice(0, 300)}`
@@ -37164,21 +37714,43 @@ async function fetchBase(worktreePath, repo, w = UNWATCHED) {
     return { ok: false, message: refused3("fetch failed", f) };
   return { ok: true, message: `fetched ${base}` };
 }
-async function pushBranch(worktreePath, branch, w = UNWATCHED) {
-  const args = ["push", "-u", "--force-with-lease", "origin", branch];
+async function pushBranch(worktreePath, branch, own, w = UNWATCHED) {
+  const theirs = `${branch} on origin holds commits that are not in the branch here: take them in first, then land again`;
+  const tip = own ? await originTip(worktreePath, branch) : null;
+  const behind = tip !== null && !await reaches(worktreePath, tip);
+  if (tip && behind && !await supersedes(worktreePath, branch, tip))
+    return { ok: false, message: theirs };
   w.step(`pushing ${branch}`);
-  let push = await w.git(worktreePath, args);
-  if (!push.ok && /stale info/.test(push.err) && await goneFromOrigin(worktreePath, branch)) {
-    await git(worktreePath, "update-ref", "-d", `refs/remotes/origin/${branch}`);
-    push = await w.git(worktreePath, args);
-  }
-  if (!push.ok)
-    return stepRefused("push failed", push, 300);
-  return { ok: true, message: `pushed ${branch}` };
-}
-async function goneFromOrigin(worktreePath, branch) {
-  const r = await run(GIT, ["ls-remote", "--exit-code", "--heads", "origin", branch], worktreePath, NO_PROMPT);
-  return !r.ok && r.exit === 2;
+  const lease = tip && behind ? [`--force-with-lease=${branch}:${tip}`] : [];
+  const push = await w.git(worktreePath, ["push", "-u", ...lease, "origin", branch]);
+  if (push.ok)
+    return { ok: true, message: `pushed ${branch}` };
+  if (/\[rejected\]|fetch first|non-fast-forward|stale info/.test(push.err))
+    return { ok: false, message: theirs };
+  return stepRefused("push failed", push, 300);
+}
+async function originTip(worktreePath, branch) {
+  const ref = `refs/heads/${branch}`;
+  const r = await run(GIT, ["ls-remote", "origin", ref], worktreePath, NO_PROMPT);
+  if (!r.ok)
+    return null;
+  const line = r.out.split(`
+`).find((l) => l.split("\t")[1] === ref);
+  return line?.split("\t")[0] || null;
+}
+async function supersedes(worktreePath, branch, tip) {
+  const [pushed, stood, lacking] = await Promise.all([
+    git(worktreePath, "reflog", "show", "--format=%H %gs", `refs/remotes/origin/${branch}`),
+    git(worktreePath, "reflog", "show", "--format=%H", `refs/heads/${branch}`),
+    git(worktreePath, "rev-list", "--count", "--cherry-pick", "--left-only", `${tip}...HEAD`)
+  ]);
+  if (pushed.ok && pushed.out.split(`
+`).includes(`${tip} update by push`))
+    return true;
+  if (stood.ok && stood.out.split(`
+`).includes(tip))
+    return true;
+  return lacking.ok && lacking.out === "0";
 }
 async function openPr(o, w = UNWATCHED) {
   const cErr = await requireClean(o.worktreePath);
@@ -37191,7 +37763,7 @@ async function openPr(o, w = UNWATCHED) {
   const remote = await git(o.worktreePath, "remote", "get-url", "origin");
   if (!remote.ok)
     return { ok: false, message: "no 'origin' remote: add one, or land by merging here" };
-  const push = await pushBranch(o.worktreePath, o.branch, w);
+  const push = await pushBranch(o.worktreePath, o.branch, o.own, w);
   if (!push.ok)
     return push;
   w.step("creating the PR");
@@ -37267,358 +37839,761 @@ function compareUrl(remoteUrl, base, branch) {
   return `${repo}/compare/${encodeURIComponent(base)}...${encodeURIComponent(branch)}?expand=1`;
 }
 
-// ../daemon/src/git/turn.ts
-import { copyFileSync, existsSync as existsSync35, rmSync as rmSync7 } from "fs";
-import { join as join31 } from "path";
-var turnRef = (worktreeId, which) => `refs/toyon/turns/${worktreeId}/${which}`;
-var SNAPSHOT_SUBJECT2 = "toyon: tree at a send";
-var queue = new Map;
-function inTurn(wtPath, job) {
-  const next = (queue.get(wtPath) ?? Promise.resolve()).then(job, job);
-  queue.set(wtPath, next.catch(() => {}));
-  return next;
-}
-var synced = new Map;
-var MAX_PATHS = 400;
-async function treeNow(wtPath, head, dirty) {
-  let was = synced.get(wtPath);
-  let index = was?.index;
-  if (!index) {
-    const dir = await git(wtPath, "rev-parse", "--absolute-git-dir");
-    if (!dir.ok || !dir.out)
-      return null;
-    index = join31(dir.out, "toyon-turn-index");
+// ../daemon/src/worktrees/ship.ts
+var REFUSAL_CHARS = 400;
+var uncounted = (base) => ({
+  ok: false,
+  message: `could not count the commits ahead of ${base}; try again`
+});
+var commandLine = (args) => args.map((a) => /^[\w./:=@,+-]+$/.test(a) ? a : JSON.stringify(a.split(`
+`, 1)[0])).join(" ");
+
+class Ship {
+  d;
+  ops = new Map;
+  syncQueued = new Set;
+  handChecked = new Map;
+  handWaits = new Set;
+  constructor(d) {
+    this.d = d;
   }
-  const env = { GIT_INDEX_FILE: index };
-  const writeTree = async () => {
-    const tree = await run(GIT, ["write-tree"], wtPath, env);
-    return tree.ok && tree.out ? tree.out : null;
-  };
-  if (!existsSync35(index))
-    was = undefined;
-  const paths = dirty && !dirty.some((f) => /[RC]/.test(f.xy)) ? dirty.map((f) => f.path) : null;
-  if (was && paths && was.head === head) {
-    const again = [...new Set([...was.dirty, ...paths])];
-    if (again.length <= MAX_PATHS) {
-      const added = again.length === 0 || (await run(GIT, ["--literal-pathspecs", "add", "-A", "--", ...again], wtPath, env)).ok;
-      const tree = added ? await writeTree() : null;
-      if (tree) {
-        synced.set(wtPath, { index, head, dirty: new Set(paths) });
-        return tree;
-      }
-    }
+  syncWaiting(id) {
+    return this.syncQueued.has(id);
   }
-  synced.delete(wtPath);
-  if (!existsSync35(index)) {
-    const own = join31(index, "..", "index");
-    if (existsSync35(own))
-      copyFileSync(own, index);
-    else if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
-      return null;
+  forget(id) {
+    this.syncQueued.delete(id);
+    this.handWaits.delete(id);
+    this.handChecked.delete(id);
   }
-  const full = async () => (await run(GIT, ["add", "-A"], wtPath, env)).ok ? writeTree() : null;
-  let tree = await full();
-  if (!tree) {
-    rmSync7(index, { force: true });
-    if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
+  setPr(worktreeId, pr) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt || wt.pr === undefined && pr === undefined)
+      return;
+    const pending = prPending(wt);
+    if (pr)
+      wt.pr = pr;
+    else
+      delete wt.pr;
+    this.d.state.save();
+    if (pending && !prPending(wt) && this.handChecked.delete(worktreeId))
+      this.d.tree.invalidate(worktreeId);
+    this.d.hub.emit("worktreesChanged");
+  }
+  async refreshLanded(wt, facts) {
+    if (wt.kind === "main")
+      return;
+    const f = facts ?? await this.landedFacts(wt);
+    if (f)
+      this.setLanded(wt, landedNow(wt, f));
+  }
+  async settleLanded(wt) {
+    const repo = this.d.state.repo(wt.repoId);
+    const f = wt.kind === "main" || !repo ? null : await this.landedFacts(wt);
+    delete wt.landing;
+    let held;
+    if (f && repo) {
+      held = notLandedWhy(wt, f, baseOf(repo));
+      if (held) {
+        delete wt.landed;
+        log.warn(wt.id, `landed, but not marked landed: ${held}`);
+      } else
+        wt.landed = true;
+    }
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
+    return held;
+  }
+  async landedFacts(wt) {
+    const repo = this.d.state.repo(wt.repoId);
+    if (!repo)
       return null;
-    tree = await full();
-    if (!tree)
+    try {
+      const [head, ab] = await Promise.all([git(wt.path, "rev-parse", "HEAD"), aheadBehind(wt.path, baseOf(repo))]);
+      if (!head.ok)
+        return null;
+      return { head: head.out, ahead: ab.ahead };
+    } catch (e) {
+      log.warn(wt.id, "could not read the tree for the landed mark", e);
       return null;
+    }
   }
-  const differs = await git(wtPath, "diff", "--name-only", "--no-renames", "-z", head, tree);
-  if (differs.ok)
-    synced.set(wtPath, { index, head, dirty: new Set(differs.out.split("\x00").filter(Boolean)) });
-  return tree;
-}
-async function snapshotAt(wtPath, ref) {
-  const r = await git(wtPath, "rev-parse", "--quiet", `${ref}^{commit}`, `${ref}^{tree}`, `${ref}^`);
-  const [commit, tree, parent] = r.ok ? r.out.split(`
-`) : [];
-  return commit && tree && parent ? { commit, tree, parent } : null;
-}
-function markTurn(wtPath, worktreeId) {
-  return inTurn(wtPath, async () => {
-    const head = await git(wtPath, "rev-parse", "--verify", "HEAD");
-    if (!head.ok)
-      return;
-    const tree = await treeNow(wtPath, head.out);
-    if (!tree)
+  setLanded(wt, landed) {
+    if (!!wt.landed === landed)
       return;
-    const at = await snapshotAt(wtPath, turnRef(worktreeId, "at"));
-    if (at?.tree === tree && at.parent === head.out)
+    if (landed)
+      wt.landed = true;
+    else
+      delete wt.landed;
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
+  }
+  fingerprint(path) {
+    return (this.d.fingerprint ?? treeFingerprint)(path);
+  }
+  setLanding(worktreeId, landing) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt || wt.landing === undefined && landing === undefined)
       return;
-    const commit = await git(wtPath, "-c", "user.name=toyon", "-c", "user.email=toyon@localhost", "commit-tree", tree, "-p", head.out, "-m", SNAPSHOT_SUBJECT2);
-    if (!commit.ok)
+    if (landing)
+      wt.landing = landing;
+    else
+      delete wt.landing;
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
+  }
+  landable(worktreeId, verb) {
+    const pair = this.d.state.requireWorktreeWithRepo(worktreeId);
+    if (isMain(pair.wt))
+      throw new UserError(`${verb} from a worktree, not main`);
+    if (!canLand(pair.wt))
+      throw new UserError(`${pair.wt.title} is a PR under review; it lands upstream, not here`);
+    return pair;
+  }
+  suggestion(wt, typed) {
+    const m = typed?.trim();
+    if (m)
+      return m;
+    const s = wt.landing?.subject;
+    if (!s)
       return;
-    if (at && at.tree !== tree)
-      await git(wtPath, "update-ref", turnRef(worktreeId, "before"), at.commit);
-    await git(wtPath, "update-ref", turnRef(worktreeId, "at"), commit.out);
-  });
-}
-function turnChanges(wtPath, worktreeId, defaultBr, own, dirty) {
-  return inTurn(wtPath, async () => {
-    const at = await snapshotAt(wtPath, turnRef(worktreeId, "at"));
-    if (!at)
-      return null;
-    const head = await git(wtPath, "rev-parse", "HEAD", "HEAD^{tree}");
-    const [headCommit, headTree] = head.ok ? head.out.split(`
-`) : [];
-    if (!headCommit)
-      return null;
-    const tree = await treeNow(wtPath, headCommit, dirty);
-    if (!tree)
-      return null;
-    const from = at.tree !== tree ? at : await snapshotAt(wtPath, turnRef(worktreeId, "before"));
-    if (!from || from.tree === tree || from.tree === headTree)
+    return wt.landing?.body ? `${s}
+
+${wt.landing.body}` : s;
+  }
+  commitMessage(wt, typed) {
+    const m = this.suggestion(wt, typed);
+    if (m)
+      return m;
+    throw new UserError("no commit message yet: write one in the changes panel");
+  }
+  async commitIfDirty(wt, typed) {
+    if ((await statusFiles(wt.path)).length === 0)
       return null;
-    if (from.parent !== headCommit) {
-      if (!own)
-        return null;
-      const [then, now] = await Promise.all([
-        git(wtPath, "merge-base", from.parent, defaultBr),
-        git(wtPath, "merge-base", headCommit, defaultBr)
-      ]);
-      if (!then.ok || !now.ok || then.out !== now.out)
-        return null;
+    return this.commitRecorded(wt, this.commitMessage(wt, typed));
+  }
+  async commitRecorded(wt, message) {
+    const result = await commitWorktree(wt.path, message, this.landWatch(wt));
+    if (result.ok) {
+      await this.verdictSurvives(wt, { dropMessage: true });
+      await this.d.headMoved(wt.id);
     }
-    const files = await filesBetween(wtPath, from.commit, tree);
-    return files.length > 0 ? { base: from.commit, files } : null;
-  });
-}
-async function dropTurnRefs(repoPath, worktreeId) {
-  for (const which of ["at", "before"])
-    await git(repoPath, "update-ref", "-d", turnRef(worktreeId, which));
-}
-
-// ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync9, readdirSync as readdirSync9, readFileSync as readFileSync21, renameSync as renameSync7, rmSync as rmSync8, writeFileSync as writeFileSync13 } from "fs";
-import { basename as basename13, dirname as dirname14, join as join32 } from "path";
-class WorktreeArchive {
-  dir;
-  records = new Map;
-  constructor(dir) {
-    this.dir = dir;
-    mkdirSync9(dir, { recursive: true });
-    for (const id of readdirSync9(dir)) {
-      const file = this.filesOf(id).record;
-      if (!existsSync36(file))
-        continue;
-      try {
-        this.records.set(id, JSON.parse(readFileSync21(file, "utf8")));
-      } catch (e) {
-        log.warn("archive", `skipped an unreadable record: ${file}`, e);
+    return result;
+  }
+  landWatch(wt) {
+    const repo = this.d.state.requireRepo(wt.repoId);
+    return {
+      step: (name) => this.step(wt.id, name),
+      git: async (cwd, args) => {
+        const where = cwd === wt.path ? "git" : `git -C ${cwd}`;
+        const commit = args[0] === "commit";
+        const ceiling = commit ? timeoutFor(repo.config, "commit") : STEP_TIMEOUT_MS;
+        const handle = commit ? this.d.runs.begin(wt.id, "commit", { timeoutMs: ceiling }) : null;
+        const run = (onText, signal) => stepRun(cwd, args, onText, signal, {
+          timeoutMs: ceiling,
+          ...handle ? { onSpawn: handle.spawned } : {},
+          onHook: (hook) => handle?.stage(hook ? `${hook} hook` : undefined)
+        });
+        const watched = async () => {
+          if (!this.d.watch)
+            return run(() => {});
+          const command = `${where} ${commandLine(args)}`;
+          try {
+            return { ...await this.d.watch(wt.id, command, run), command };
+          } catch (e) {
+            log.warn(wt.id, `landing step runs unwatched: ${e instanceof Error ? e.message : e}`);
+            return run(() => {});
+          }
+        };
+        const r = await watched();
+        handle?.finish(r.exit);
+        return r;
       }
+    };
+  }
+  async verdictSurvives(wt, opts) {
+    const l = wt.landing;
+    if (!l || l.check === "pending")
+      return;
+    const { subject, body, unanswered, ...kept } = l;
+    const message = opts.dropMessage ? {} : { ...subject ? { subject } : {}, ...body ? { body } : {}, ...unanswered ? { unanswered } : {} };
+    this.setLanding(wt.id, { ...kept, ...message, fingerprint: await this.fingerprint(wt.path) });
+  }
+  async landedByHand(wt, mark) {
+    const repo = this.d.state.requireRepo(wt.repoId);
+    const base = baseOf(repo);
+    log.info(wt.id, `landed on ${base} outside toyon: ${mark.base.slice(0, 7)}..${mark.tip.slice(0, 7)}`);
+    await this.landing(wt, "auto", async () => ({
+      result: { ok: true, message: `landed on ${base} outside toyon` },
+      landed: true,
+      unsaid: true,
+      ...await this.settle(wt, repo, mark)
+    }));
+  }
+  async landing(wt, by, run) {
+    const out = await this.ship(wt.id, "land", by, async () => {
+      await this.followBranch(wt);
+      return run();
+    });
+    if (out.result.ok && out.landed)
+      this.noteLanded(wt, out);
+    return out;
+  }
+  async land(worktreeId, message) {
+    const { wt, repo } = this.landable(worktreeId, "land");
+    const out = await this.landing(wt, "press", async () => {
+      const on = await git(wt.path, "branch", "--show-current");
+      if (on.ok && !on.out)
+        throw new UserError(`${wt.title} is detached: check out a branch in it first`);
+      const moved = await this.movedMidTurn(wt);
+      if (moved)
+        return { result: moved };
+      return this.landOp(wt, repo, message);
+    });
+    return { result: this.fixShip(wt, out.result, baseOf(repo)) };
+  }
+  fixShip(wt, result, base) {
+    if (result.ok)
+      return result;
+    if (result.hook?.name === "commit-msg") {
+      this.d.hub.emit("messageRefused", wt.id, result.hook.text.trim().slice(-REFUSAL_CHARS));
+      return { ...result, message: "the commit-msg hook refused the message: another is being written" };
     }
+    const { hook } = result;
+    const failure = hook ? { kind: "hook", hook: hook.name, toolId: hook.toolId, command: hook.command, text: hook.text } : result.conflict ? {
+      kind: "conflict",
+      base,
+      how: result.conflict,
+      ...result.step ? { step: result.step } : {},
+      ...result.carried ? { carried: result.carried } : {}
+    } : null;
+    return failure && this.d.fix.report(wt.id, failure) ? { ...result, asked: true } : result;
   }
-  get(id) {
-    return this.records.get(id);
+  async movedMidTurn(wt) {
+    if (!isBusy(this.d.runtime.agentFor(wt.id)?.status))
+      return null;
+    const l = wt.landing;
+    if (!l || l.fingerprint === await this.fingerprint(wt.path))
+      return null;
+    return { ok: false, message: "the agent has changed files since the check: land once its turn ends" };
   }
-  put(rec, from) {
-    const at = this.filesOf(rec.worktree.id);
-    mkdirSync9(at.dir, { recursive: true });
-    move(from.transcript, at.transcript);
-    move(from.attachments, at.attachments);
-    move(from.plans, at.plans);
-    writeFileSync13(at.record, JSON.stringify(rec, null, 2));
-    this.records.set(rec.worktree.id, rec);
-    return { transcript: at.transcript, attachments: at.attachments, plans: at.plans };
+  noteLanded(wt, o) {
+    if (!o.unsaid) {
+      this.d.runtime.ensureAgent(wt).agent.note({
+        type: "landed",
+        message: o.result.message,
+        ...o.mark ? { mark: o.mark } : {},
+        ...o.url ? { url: o.url } : {},
+        ...o.held ? { held: o.held } : {},
+        ts: Date.now()
+      });
+    }
+    this.d.hub.emit("landed", wt.id);
   }
-  take(id, to) {
-    if (!this.records.has(id))
+  async followBranch(wt, current) {
+    if (wt.kind === "main")
       return;
-    const at = this.filesOf(id);
-    move(at.transcript, to.transcript);
-    move(at.attachments, to.attachments);
-    move(at.plans, to.plans);
-    this.delete(id);
-  }
-  delete(id) {
-    if (!this.records.has(id))
+    const branch = current ?? (await git(wt.path, "branch", "--show-current")).out;
+    if (!branch || branch === wt.branch)
       return;
-    rmSync8(this.filesOf(id).dir, { recursive: true, force: true });
-    this.records.delete(id);
+    log.info(wt.id, `on ${branch} now, not ${wt.branch}: the row follows the checkout`);
+    wt.branch = branch;
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
   }
-  list(repo) {
-    return this.recordsOf(repo).sort((a, b) => b.archivedAt - a.archivedAt).map((r) => summarize(r, repo.id, this.filesOf(r.worktree.id).transcript));
+  shippingOf(id) {
+    return this.ops.get(id);
   }
-  recordsOf(repo) {
-    return [...this.records.values()].filter((r) => r.worktree.repoId === repo.id || r.repoPath === repo.path);
+  async ship(id, op, by, run) {
+    const out = this.ops.get(id);
+    if (out)
+      throw new UserError(`${shipNoun(out.op)} is already running here`);
+    const release = this.d.runtime.agentFor(id)?.hold();
+    this.ops.set(id, { op });
+    if (by === "press")
+      this.d.stampPrompted(id);
+    this.d.hub.emit("worktreesChanged");
+    const started = Date.now();
+    const watchdog = setInterval(() => {
+      const step = this.ops.get(id)?.step;
+      const at = step ? ` at "${step}"` : "";
+      log.warn(id, `${shipNoun(op)} still running after ${describeDuration(Date.now() - started)}${at}`);
+    }, RUN_CEILING_MS);
+    watchdog.unref?.();
+    try {
+      return await run();
+    } finally {
+      clearInterval(watchdog);
+      this.ops.delete(id);
+      release?.();
+      if (this.handWaits.delete(id))
+        this.d.tree.invalidate(id);
+      this.d.hub.emit("worktreesChanged");
+      if (!isBusy(this.d.runtime.agentFor(id)?.status))
+        this.syncAfterTurn(id);
+    }
   }
-  save(id) {
-    const rec = this.records.get(id);
-    if (!rec)
+  step(id, name) {
+    const out = this.ops.get(id);
+    if (!out || out.step === name)
       return;
-    writeFileSync13(this.filesOf(id).record, JSON.stringify(rec, null, 2));
+    out.step = name;
+    this.d.hub.emit("worktreesChanged");
   }
-  chatFiles(id) {
-    if (!this.records.has(id))
-      return;
-    const at = this.filesOf(id);
-    return { transcript: at.transcript, attachments: at.attachments, plans: at.plans };
+  async messageOwed(wt, typed, w) {
+    if (!this.d.message || this.suggestion(wt, typed))
+      return typed;
+    if ((await statusFiles(wt.path)).length === 0)
+      return typed;
+    w.step("writing the message");
+    return await this.d.message(wt) ?? typed;
   }
-  planFile(id, rel) {
-    if (!this.records.has(id) || !isPlanPath(rel))
-      return null;
-    const file = join32(this.filesOf(id).plans, basename13(rel));
-    if (!existsSync36(file))
-      return null;
-    try {
-      return readFileSync21(file, "utf8");
-    } catch (e) {
-      log.warn(id, `could not read its archived plan ${rel}`, e);
-      return null;
+  async landOp(wt, repo, typed) {
+    const policy = landPolicy(repo.config);
+    const w = this.landWatch(wt);
+    const message = await this.messageOwed(wt, typed, w);
+    const suggested = this.suggestion(wt, message);
+    if (policy.land === "pr")
+      return this.landPr(wt, repo, policy, message, suggested, w);
+    if (policy.land === "push")
+      return this.landPush(wt, repo, policy, message, suggested, w);
+    return this.landLocal(wt, repo, policy, message, suggested, w);
+  }
+  async landPr(wt, repo, policy, message, suggested, w) {
+    const base = baseOf(repo);
+    const own = hasOwnBranch(wt);
+    if (wt.pr?.state === "merged" && !prTaken(wt))
+      return this.prMergedOp(wt, undefined, w);
+    const fetched = await this.fetchBase(wt, repo, w);
+    if (!fetched.ok)
+      return { result: fetched };
+    if (wt.pr?.state === "open") {
+      const dirty = (await statusFiles(wt.path)).length > 0;
+      const missing = dirty || (await aheadUpstream(wt.path, wt.branch) ?? 0) > 0;
+      if (!missing) {
+        const result = await mergePr(wt.path, wt.pr.number, policy.merge, w);
+        if (result.ok && result.queued)
+          this.setPr(wt.id, { ...wt.pr, queue: true, queued: "waiting", at: Date.now() });
+        return { result };
+      }
+      const committed = await this.commitIfDirty(wt, message);
+      if (committed && !committed.ok)
+        return { result: committed };
+      this.d.tree.invalidate(wt.id);
+      const taken = await takeMainIn(wt.path, base, own, w);
+      if (!taken.ok)
+        return { result: taken };
+      await this.d.headMoved(wt.id);
+      this.d.tree.invalidate(wt.id);
+      const pushed = await pushBranch(wt.path, wt.branch, own, w);
+      if (!pushed.ok)
+        return { result: pushed };
+      await this.d.headMoved(wt.id);
+      this.setLanding(wt.id, undefined);
+      const did = committed ? "committed and pushed" : "pushed";
+      if (wt.pr.queued) {
+        const { queued: _, ...left } = wt.pr;
+        this.setPr(wt.id, { ...left, at: Date.now() });
+        return {
+          result: {
+            ok: true,
+            url: wt.pr.url,
+            message: `${did}; PR #${wt.pr.number} has the new commits and left the merge queue: land it again once it is ready`
+          }
+        };
+      }
+      return { result: { ok: true, url: wt.pr.url, message: `${did}; PR #${wt.pr.number} has the new commits` } };
+    }
+    const committed = await this.commitIfDirty(wt, message);
+    if (committed && !committed.ok)
+      return { result: committed };
+    const mark = await landingMark(wt.path, base);
+    this.d.tree.invalidate(wt.id);
+    const taken = await takeMainIn(wt.path, base, own, w);
+    if (!taken.ok)
+      return { result: taken };
+    await this.d.headMoved(wt.id);
+    const ahead = await aheadOf(wt.path, base);
+    if (ahead === null)
+      return { result: uncounted(base) };
+    if (ahead === 0) {
+      const landed = await this.prMergedOp(wt, mark, w);
+      const on = `origin's ${repo.defaultBranch} has this work already`;
+      return { ...landed, result: { ...landed.result, message: `${on}; ${landed.result.message}` } };
+    }
+    const named = !suggested ? undefined : splitMessage(policy.merge === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : suggested);
+    const result = await openPr({
+      worktreePath: wt.path,
+      branch: wt.branch,
+      defaultBr: repo.defaultBranch,
+      base,
+      subject: named?.subject,
+      body: named?.body,
+      automerge: policy.automerge,
+      own,
+      method: policy.merge
+    }, w);
+    if (result.ok) {
+      this.setLanding(wt.id, undefined);
+      if (result.pr)
+        this.setPr(wt.id, { ...result.pr, at: Date.now() });
     }
+    return { result };
   }
-  filesOf(id) {
-    const dir = join32(this.dir, id);
-    return {
-      dir,
-      record: join32(dir, "record.json"),
-      transcript: join32(dir, "transcript.jsonl"),
-      attachments: join32(dir, "attachments"),
-      plans: join32(dir, "plans")
+  landLocal(wt, repo, policy, message, suggested, w) {
+    const base = baseOf(repo);
+    const own = hasOwnBranch(wt);
+    return withRepoLock(repo.path, async () => {
+      const committed = await this.commitIfDirty(wt, message);
+      if (committed && !committed.ok)
+        return { result: committed };
+      const method = policy.merge ?? DEFAULT_MERGE_METHOD;
+      const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
+      if (merged)
+        return { result: merged };
+      const taken = await takeMainIn(wt.path, base, own, w);
+      if (!taken.ok)
+        return { result: taken };
+      const mark = await landingMark(wt.path, base);
+      const squash = method === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : "";
+      const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash, w);
+      if (!landed.ok)
+        return { result: landed };
+      const settled = await this.settle(wt, repo, mark, { squash });
+      const did = committed ? "committed and merged" : "merged";
+      return { result: { ...landed, message: `${did} into ${repo.defaultBranch}` }, landed: true, ...settled };
+    });
+  }
+  async landPush(wt, repo, policy, message, suggested, w) {
+    const base = baseOf(repo);
+    const own = hasOwnBranch(wt);
+    const method = policy.merge ?? DEFAULT_MERGE_METHOD;
+    const committed = await this.commitIfDirty(wt, message);
+    if (committed && !committed.ok)
+      return { result: committed };
+    const read = await landingMark(wt.path, base);
+    if (!read)
+      return { result: { ok: false, message: `nothing to land: no commits ahead of ${base}` } };
+    let sha = "";
+    let already = false;
+    let squash = "";
+    const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
+    if (merged)
+      return { result: merged };
+    for (let attempt = 0;; attempt++) {
+      const fetched = await this.fetchBase(wt, repo, w);
+      if (!fetched.ok)
+        return { result: fetched };
+      this.d.tree.invalidate(wt.id);
+      const taken = await takeMainIn(wt.path, base, own, w);
+      if (!taken.ok)
+        return { result: taken };
+      await this.d.headMoved(wt.id);
+      const ahead = await aheadOf(wt.path, base);
+      if (ahead === null)
+        return { result: uncounted(base) };
+      if (ahead === 0) {
+        already = true;
+        sha = await commitOf(wt.path, base) ?? "";
+        break;
+      }
+      squash = method === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : "";
+      this.d.tree.invalidate(wt.id);
+      const built = await landingCommit(wt.path, wt.branch, base, method, squash, own, w);
+      await this.d.headMoved(wt.id);
+      if (!built.ok || !built.sha)
+        return { result: built };
+      sha = built.sha;
+      const pushed = await pushLanding(wt.path, sha, repo.defaultBranch, w);
+      if (pushed.ok)
+        break;
+      if (!pushed.moved)
+        return { result: pushed };
+      if (attempt > 0) {
+        return { result: { ok: false, message: `${base} moved twice while this landed; land again` } };
+      }
+    }
+    if (await commitOf(wt.path, base) !== sha)
+      await this.fetchBase(wt, repo, w);
+    const settled = await withRepoLock(repo.path, () => this.settle(wt, repo, read, { squash }));
+    const followed = await this.d.trunk.catchUp(repo.id);
+    const here = followed.ok ? `${repo.defaultBranch} here ${followed.moved ? "pulled it" : "has it"}` : `${repo.defaultBranch} here was left where it is: ${followed.message}`;
+    const how = { merge: "merged into", squash: "squashed onto", rebase: "rebased onto" }[method];
+    const did = already ? `origin's ${repo.defaultBranch} has this work already` : `${committed ? `committed and ${how}` : how} ${repo.defaultBranch} and pushed`;
+    return { result: { ok: true, message: `${did}; ${here}` }, landed: true, ...settled };
+  }
+  async settle(wt, repo, mark, opts = {}) {
+    const noted = await this.noteLand(repo, wt, mark, opts);
+    if (!opts.stay)
+      await this.restartFromMain(wt, baseOf(repo));
+    this.d.tree.invalidateAll();
+    return { mark: noted, held: await this.settleLanded(wt) };
+  }
+  async noteLand(repo, wt, mark, opts = {}) {
+    if (!mark)
+      return;
+    const n = wt.lands?.length ?? 0;
+    const pinned = await git(repo.path, "update-ref", landRef(wt.id, n), mark.tip);
+    if (!pinned.ok) {
+      log.warn(wt.id, `could not keep the commits it landed: ${pinned.err}`);
+      return;
+    }
+    const noted = {
+      ...mark,
+      at: Date.now(),
+      ...opts.pr ? { pr: opts.pr.number } : {},
+      subjects: await this.landedWhat(repo, wt, mark, opts)
     };
+    wt.lands = [...wt.lands ?? [], noted];
+    this.d.state.save();
+    return noted;
   }
-}
-function summarize(r, repoId, transcript) {
-  return {
-    id: r.worktree.id,
-    repoId,
-    title: r.worktree.title,
-    branch: r.worktree.branch,
-    path: r.worktree.path,
-    createdAt: r.worktree.createdAt,
-    archivedAt: r.archivedAt,
-    ...r.prompt ? { prompt: r.prompt } : {},
-    restorable: !!r.kept,
-    transcript,
-    ...r.sessionId ? { sessionId: r.sessionId } : {},
-    ...r.kept?.snapshot ? { uncommitted: true, ...r.kept.dirty ? { dirty: r.kept.dirty } : {} } : {},
-    ...r.worktree.landed ? { landed: true } : {},
-    ...r.worktree.lands?.length ? { lands: r.worktree.lands } : {},
-    ...r.cost !== undefined ? { cost: r.cost } : {},
-    ...r.auto ? { auto: r.auto } : {}
-  };
-}
-function lastUsage(transcript) {
-  if (!existsSync36(transcript))
-    return null;
-  const lines = readFileSync21(transcript, "utf8").split(`
-`);
-  for (let i = lines.length - 1;i >= 0; i--) {
-    if (!lines[i]?.includes('"usage"'))
-      continue;
-    try {
-      const e = JSON.parse(lines[i]).event;
-      if (e?.type === "usage")
-        return { used: e.used, size: e.size, ...e.cost !== undefined ? { cost: e.cost } : {} };
-    } catch {}
+  async landedWhat(repo, wt, mark, opts) {
+    if (opts.pr?.title)
+      return [opts.pr.title];
+    const subject = opts.squash ? splitMessage(opts.squash).subject : "";
+    if (subject)
+      return [subject];
+    const read = await rangeSubjects(repo.path, mark.base, mark.tip);
+    if (!read)
+      log.warn(wt.id, `could not read what it landed: ${mark.base.slice(0, 7)}..${mark.tip.slice(0, 7)}`);
+    return read ?? [];
   }
-  return null;
-}
-function firstPrompt(transcript) {
-  if (!existsSync36(transcript))
-    return;
-  for (const line of readFileSync21(transcript, "utf8").split(`
-`)) {
-    if (!line.includes('"user-message"') && !line.includes('"handed"'))
-      continue;
-    try {
-      const event = JSON.parse(line).event;
-      if (event?.type === "user-message")
-        return event.text.slice(0, 500);
-      if (event?.type === "handed")
-        return (event.body ?? event.text).slice(0, 500);
-    } catch {}
+  async tipMark(wt) {
+    const head = await git(wt.path, "rev-parse", "HEAD");
+    return head.ok ? { base: head.out, tip: head.out } : null;
   }
-  return;
-}
-function move(from, to) {
-  if (!existsSync36(from))
-    return;
-  mkdirSync9(dirname14(to), { recursive: true });
-  rmSync8(to, { recursive: true, force: true });
-  renameSync7(from, to);
-}
-
-// ../daemon/src/worktrees/archivedGit.ts
-class ArchivedGit {
-  repoPath;
-  kept;
-  lands;
-  defaultBr;
-  constructor(repoPath, kept, lands, defaultBr) {
-    this.repoPath = repoPath;
-    this.kept = kept;
-    this.lands = lands;
-    this.defaultBr = defaultBr;
+  async restartFromMain(wt, base) {
+    if (!hasOwnBranch(wt))
+      return;
+    this.d.tree.invalidate(wt.id);
+    const r = await git(wt.path, "reset", "--keep", base);
+    if (!r.ok)
+      log.warn(wt.id, `could not restart ${wt.branch} from ${base}: ${r.err}`);
+    await this.d.tree.refresh(wt.id);
   }
-  async tailBase() {
-    const r = await git(this.repoPath, "merge-base", this.kept.head, this.defaultBr);
-    return r.ok && r.out ? r.out : this.kept.head;
+  async fetchBase(wt, repo, w) {
+    if (!baseIsRemote(repo))
+      return { ok: true, message: `${baseOf(repo)} here is the base` };
+    const r = await withFetchLock(repo.path, () => fetchBase(wt.path, repo, w));
+    this.d.trunk.noteFetch(repo.id, { ok: r.ok, err: r.message });
+    return r;
   }
-  async status() {
-    const base = await this.tailBase();
-    const { head, snapshot } = this.kept;
-    const [files, committed] = await Promise.all([
-      snapshot ? filesBetween(this.repoPath, head, snapshot) : [],
-      base === head ? [] : filesBetween(this.repoPath, base, head)
-    ]);
-    return { files, committed, head: snapshot ?? head };
+  async prMerged(worktreeId) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt)
+      return { ok: false, message: "that worktree is gone" };
+    const pr = wt.pr ? `PR #${wt.pr.number}` : "the PR";
+    const out = this.ops.get(worktreeId);
+    if (out) {
+      const message = `${shipNoun(out.op)} is already running here`;
+      log.info(worktreeId, `${pr} merged on GitHub; ${message}, landing waits`);
+      return { ok: false, message };
+    }
+    if (prTaken(wt))
+      return { ok: true, message: `${pr} merged; landed already` };
+    log.info(worktreeId, `${pr} merged on GitHub; landing it`);
+    const { result } = await this.landing(wt, "auto", () => this.prMergedOp(wt));
+    if (result.ok)
+      log.info(worktreeId, `landed: ${result.message}`);
+    else
+      log.warn(worktreeId, `landing failed: ${result.message}`);
+    return result;
   }
-  async log() {
-    const seen = new Set;
-    const unseen = (list) => {
-      const out = list.filter((c) => !seen.has(c.sha));
-      for (const c of out)
-        seen.add(c.sha);
-      return out;
-    };
-    const landed = [];
-    for (const land of this.lands) {
-      const commits = unseen(await logRange(this.repoPath, land.base, land.tip));
-      landed.push(commits.map((c) => ({ ...c, landedAt: land.at })));
+  async prMergedOp(wt, carried, w = UNWATCHED) {
+    const repo = this.d.state.requireRepo(wt.repoId);
+    const br = repo.defaultBranch;
+    const base = baseOf(repo);
+    const read = carried === undefined ? await landingMark(wt.path, base) : carried;
+    const pulled = await this.d.trunk.pull(repo.id, w);
+    const past = await this.pastPr(wt, base);
+    const settled = await withRepoLock(repo.path, async () => this.settle(wt, repo, await this.prMark(wt, base, read, past), { pr: wt.pr, stay: !!past }));
+    const took = pulled.ok ? `${br} here ${pulled.moved ? "pulled it" : "has it"}` : `${br} here was left where it is: ${pulled.message}`;
+    const left = past?.count ? `; ${past.count === 1 ? "a commit" : `${past.count} commits`} made since its last push stayed on the branch` : "";
+    const message = `${wt.pr ? `PR #${wt.pr.number} merged; ${took}` : took}${left}`;
+    return { result: { ok: true, message }, landed: true, url: wt.pr?.url, ...settled };
+  }
+  async prMark(wt, base, read, past) {
+    if (prTaken(wt))
+      return null;
+    const own = read ?? await handLanding(wt.path, wt.branch, base, wt.lands?.at(-1)?.tip);
+    const mark = own ?? (wt.pr ? await this.tipMark(wt) : null);
+    return mark && past?.tip ? { ...mark, tip: past.tip } : mark;
+  }
+  async pastPr(wt, base) {
+    if (!hasOwnBranch(wt))
+      return null;
+    const named = [wt.pr?.head, await remoteHead(wt.path, wt.branch)];
+    const known = [];
+    for (const sha of named)
+      if (sha && !known.includes(sha) && await commitOf(wt.path, sha))
+        known.push(sha);
+    const read = await git(wt.path, "rev-list", "HEAD", "--not", base, ...known);
+    if (!read.ok) {
+      log.warn(wt.id, `could not read what ${wt.branch} holds past its PR: ${read.err}`);
+      return { count: 0 };
+    }
+    let past = read.out.split(`
+`).filter(Boolean);
+    for (const sha of known) {
+      if (past.length === 0)
+        break;
+      const fresh = await git(wt.path, "rev-list", "--cherry-pick", "--right-only", `${sha}...HEAD`);
+      if (!fresh.ok)
+        continue;
+      const kept = new Set(fresh.out.split(`
+`));
+      past = past.filter((c) => kept.has(c));
     }
-    const base = await this.tailBase();
-    const tail = base === this.kept.head ? [] : unseen(await logRange(this.repoPath, base, this.kept.head));
-    return [...tail, ...landed.reverse().flat()];
+    const oldest = past.at(-1);
+    if (!oldest)
+      return null;
+    const tip = await git(wt.path, "rev-parse", "--verify", "--quiet", `${oldest}^`);
+    return { count: past.length, ...tip.ok && tip.out ? { tip: tip.out } : {} };
   }
-  commitFiles(sha) {
-    return commitFiles(this.repoPath, sha);
+  async sync(worktreeId, by = "press") {
+    const r = this.d.readable(worktreeId);
+    if (!r)
+      throw new UserError("that worktree is gone");
+    if (r.wt && isMain(r.wt))
+      throw new UserError("sync from a worktree, not main");
+    if (r.wt && isProvisional(r.wt))
+      throw new UserError("the new worktree already sits on main; it follows it on its own");
+    if (!r.branch)
+      throw new UserError(`${r.name} is detached: check out a branch in it first`);
+    if (r.locked)
+      throw new UserError(`${r.name} is held by another tool`);
+    const repo = this.d.state.requireRepo(r.repoId);
+    const own = r.wt ? hasOwnBranch(r.wt) : false;
+    const carry = !!r.wt;
+    const busy = isBusy(this.d.runtime.agentFor(worktreeId)?.status);
+    if (carry && busy && (await statusFiles(r.path)).length > 0) {
+      this.syncQueued.add(worktreeId);
+      if (by === "press")
+        this.d.stampPrompted(worktreeId);
+      this.d.hub.emit("worktreesChanged");
+      return { result: { ok: true, message: `${r.name} syncs from ${r.base} once the turn ends` }, base: r.base };
+    }
+    const w = r.wt ? this.landWatch(r.wt) : UNWATCHED;
+    const result = await this.ship(worktreeId, "sync-main", by, async () => {
+      if (r.wt) {
+        const fetched = await this.fetchBase(r.wt, repo, w);
+        if (!fetched.ok)
+          return fetched;
+      }
+      this.d.tree.invalidate(worktreeId);
+      const taken = await withRepoLock(repo.path, () => takeMainIn(r.path, r.base, own, w, carry));
+      if (taken.ok) {
+        await this.d.headMoved(worktreeId);
+        if (r.wt)
+          await this.verdictSurvives(r.wt, { dropMessage: false });
+      }
+      return taken;
+    });
+    return { result: r.wt ? this.fixShip(r.wt, result, r.base) : result, base: r.base };
   }
-  async file(path, ref) {
-    if (ref)
-      return fileAtCommit(this.repoPath, ref, path);
-    const base = await this.tailBase();
-    const [before, after] = await Promise.all([
-      gitRaw(this.repoPath, "show", `${base}:${path}`),
-      gitRaw(this.repoPath, "show", `${this.kept.snapshot ?? this.kept.head}:${path}`)
-    ]);
-    return { before: before.ok ? before.out : "", after: after.ok ? after.out : "" };
+  unqueueSync(worktreeId) {
+    if (!this.syncQueued.delete(worktreeId))
+      return;
+    this.d.hub.emit("worktreesChanged");
   }
-}
-
-// ../daemon/src/worktrees/landSubjects.ts
-function unfilled(mark) {
-  return mark.subjects === undefined;
-}
-async function fillLandMarks(jobs, read, width = 8) {
-  let next = 0;
-  const worker = async () => {
-    while (next < jobs.length) {
-      const job = jobs[next++];
-      if (!job)
-        return;
-      job.mark.subjects = await read(job.cwd, job.mark) ?? [];
+  syncAfterTurn(worktreeId) {
+    if (!this.syncQueued.has(worktreeId))
+      return;
+    if (this.ops.has(worktreeId))
+      return;
+    this.syncQueued.delete(worktreeId);
+    const release = this.d.runtime.agentFor(worktreeId)?.hold();
+    this.d.hub.emit("worktreesChanged");
+    fireAndForget(worktreeId, (async () => {
+      try {
+        const { result } = await this.sync(worktreeId, "auto");
+        if (!result.ok && !result.asked)
+          this.d.hub.emit("failed", worktreeId, result.message);
+      } catch (e) {
+        this.d.hub.emit("failed", worktreeId, e instanceof Error ? e.message : String(e));
+      } finally {
+        release?.();
+      }
+    })(), "sync after the turn");
+  }
+  async pull(worktreeId) {
+    const wt = this.d.state.requireWorktree(worktreeId);
+    if (!isMain(wt))
+      throw new UserError("pull on main; a worktree syncs from main instead");
+    const repo = this.d.state.requireRepo(wt.repoId);
+    const w = { step: (name) => this.step(worktreeId, name), git: UNWATCHED.git };
+    return this.ship(worktreeId, "pull-main", "auto", async () => {
+      const result = await this.d.trunk.pull(repo.id, w);
+      if (result.ok && result.moved)
+        await this.d.recountAll();
+      return result;
+    });
+  }
+  async commit(worktreeId, message) {
+    const wt = this.d.state.requireWorktree(worktreeId);
+    const m = message.trim();
+    if (!m)
+      throw new UserError("commit message required");
+    const base = baseOf(this.d.state.requireRepo(wt.repoId));
+    return this.fixShip(wt, await this.ship(wt.id, "commit", "press", () => this.commitRecorded(wt, m)), base);
+  }
+  async afterRead(r, wt, core) {
+    const isMain = wt.kind === "main";
+    if (core.branch)
+      await this.followBranch(wt, core.branch);
+    const { files, head } = core;
+    const ahead = core.ahead ?? 0;
+    if (!isMain && hasOwnBranch(wt) && files.length === 0 && ahead === 0 && head && this.handChecked.get(wt.id) !== head) {
+      this.handChecked.set(wt.id, head);
+      const mark = await handLanding(r.path, wt.branch, r.base, wt.lands?.at(-1)?.tip);
+      if (mark) {
+        const merged = prPending(wt) && (wt.pr?.state === "merged" || !!wt.pr?.head && await reaches(r.path, wt.pr.head));
+        const out = this.ops.get(wt.id);
+        if (out) {
+          this.handChecked.delete(wt.id);
+          this.handWaits.add(wt.id);
+          log.info(wt.id, `landed on ${r.base} outside toyon; ${shipNoun(out.op)} is already running here, landing waits`);
+          return false;
+        }
+        const pr = prPending(wt) ? wt.pr : undefined;
+        if (!pr) {
+          await this.landedByHand(wt, mark);
+          return true;
+        }
+        if (merged) {
+          const { queue: _had, queued: _was, ...rest } = pr;
+          if (pr.state !== "merged")
+            this.setPr(wt.id, { ...rest, state: "merged" });
+          fireAndForget(wt.id, this.prMerged(wt.id), "pr landing");
+        } else {
+          log.info(wt.id, `the work is on ${r.base}; PR #${pr.number} lands it once GitHub says it merged`);
+          this.d.hub.emit("prDue", wt.id);
+        }
+        if (this.ops.has(wt.id))
+          return false;
+      }
     }
-  };
-  await Promise.all(Array.from({ length: Math.min(width, jobs.length) }, worker));
+    if (!isMain && head) {
+      const facts = { head, ahead };
+      if (prTaken(wt) && movedPastLand(wt, facts))
+        this.setPr(wt.id, undefined);
+      await this.refreshLanded(wt, facts);
+    }
+    const landing = wt.landing;
+    if (landing && landing.check !== "pending") {
+      const moved = landing.fingerprint !== await this.fingerprint(r.path);
+      if (wt.landing === landing && moved !== !!landing.stale) {
+        const { stale: _was, ...rest } = landing;
+        this.setLanding(wt.id, moved ? { ...rest, stale: true } : rest);
+      }
+    }
+    return false;
+  }
 }
 
 // ../daemon/src/worktrees/spare.ts
 import { existsSync as existsSync37 } from "fs";
-import { basename as basename14, join as join33 } from "path";
+import { basename as basename14, join as join34 } from "path";
 class SparePool {
   d;
   inflight = new Map;
@@ -37686,11 +38661,11 @@ class SparePool {
     return this.record(repoId, repo).then((wt) => this.warmUp(wt, repo, {}));
   }
   async record(repoId, repo) {
-    const { id, dir } = freeSlot(join33(this.d.paths.worktreesDir, repo.name));
+    const { id, dir } = freeSlot(join34(this.d.paths.worktreesDir, repo.name));
     const wt = {
       id,
       repoId,
-      path: join33(this.d.paths.worktreesDir, repo.name, dir),
+      path: join34(this.d.paths.worktreesDir, repo.name, dir),
       branch: repo.defaultBranch,
       kind: "spare",
       phase: "reserved",
@@ -37882,7 +38857,7 @@ class SparePool {
 // ../daemon/src/worktrees/treeState.ts
 import { watch as watch2 } from "fs";
 import { stat as stat7 } from "fs/promises";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var EDIT_DELAY_MS = 150;
 var SHELL_QUIET_MS2 = 1500;
 var WATCH_DELAY_MS = 300;
@@ -38143,11 +39118,10 @@ class TreeState {
     });
     w.unref?.();
     this.watchers.set(id, { w, ignore });
-    fireAndForget(id, git(r.path, "ls-files", "-o", "-i", "--exclude-standard", "--directory").then((res) => {
+    fireAndForget(id, gitRaw(r.path, "ls-files", "-z", "-o", "-i", "--exclude-standard", "--directory").then((res) => {
       if (!res.ok)
         return;
-      for (const line of res.out.split(`
-`)) {
+      for (const line of nulSplit(res.out)) {
         const dir = line.replace(/\/$/, "");
         if (dir)
           ignore.add(dir);
@@ -38265,7 +39239,7 @@ class TreeState {
       xy: f.xy,
       ...entries.folded.has(f.path) ? { add: f.add, del: f.del } : {}
     }));
-    const stats = await Promise.all(files.slice(0, SIGNATURE_STATS).map((f) => stat7(join34(r.path, f.path)).then((s) => `${s.mtimeMs}:${s.size}`, () => "-")));
+    const stats = await Promise.all(files.slice(0, SIGNATURE_STATS).map((f) => stat7(join35(r.path, f.path)).then((s) => `${s.mtimeMs}:${s.size}`, () => "-")));
     const t0 = performance.now();
     const counts = { ...ab, ...unpushed === null ? {} : { unpushed } };
     const signature = String(Bun.hash([
@@ -38588,7 +39562,6 @@ function stopOf(prev, next) {
 var LIST_FLOOR_MS = 1e4;
 var LOCAL_CONFIG_FILES = [".env", ".env.local", ".env.development", ".env.development.local", ".dev.vars"];
 var BASE_IGNORE = "base .gitignore";
-var REFUSAL_CHARS = 400;
 async function deleteTree(path) {
   try {
     await rm6(path, { recursive: true, force: true });
@@ -38616,16 +39589,13 @@ var idsOf = (rows, trunks) => [
   ...Object.values(trunks).map((t) => t.id)
 ];
 var heldBy2 = (found) => `${found.name} is held by another tool${found.lockReason ? `: ${found.lockReason}` : ""}`;
-var commandLine = (args) => args.map((a) => /^[\w./:=@,+-]+$/.test(a) ? a : JSON.stringify(a.split(`
-`, 1)[0])).join(" ");
 
 class WorktreeService {
   d;
   spare;
   runs;
-  ops = new Map;
-  syncQueued = new Set;
   trunk;
+  ship;
   archive;
   archiving = new Map;
   restoring = new Map;
@@ -38633,7 +39603,6 @@ class WorktreeService {
   arriving = new Set;
   firstPrompt = new Map;
   tree;
-  handChecked = new Map;
   naming = new Set;
   discoverCache = new Map;
   relisting = new Map;
@@ -38663,6 +39632,22 @@ class WorktreeService {
       afterCore: (r, core) => this.afterCore(r, core),
       rowsOf: (repoId) => this.rowsOf(repoId)
     });
+    this.ship = new Ship({
+      state: d.state,
+      hub: d.hub,
+      runtime: d.runtime,
+      fix: d.fix,
+      runs: this.runs,
+      tree: this.tree,
+      trunk: this.trunk,
+      readable: (id) => this.readable(id),
+      stampPrompted: (id) => this.stampPrompted(id),
+      headMoved: (id) => this.headMoved(id),
+      recountAll: () => this.recountAll(),
+      watch: d.watch,
+      fingerprint: d.fingerprint,
+      message: d.message
+    });
     this.spare = new SparePool({
       state: d.state,
       hub: d.hub,
@@ -38711,7 +39696,7 @@ class WorktreeService {
           this.scheduleNaming(wt, prompt);
       }
       if (turn.end !== "asking")
-        this.syncAfterTurn(worktreeId);
+        this.ship.syncAfterTurn(worktreeId);
       if (turn.end !== "done" && turn.end !== "stopped")
         return;
       for (const p of d.runtime.get(worktreeId)?.procs?.states() ?? []) {
@@ -38790,8 +39775,8 @@ class WorktreeService {
     if (!await isGitRepo(repo.path)) {
       throw new UserError(`git no longer reads ${repo.name} as a checkout, so there is nothing to start a worktree from. If \`git config core.bare\` says true there, \`git config --unset core.bare\` puts it back.`);
     }
-    const { id, dir } = freeSlot(join35(this.d.paths.worktreesDir, repo.name));
-    const wtPath = join35(this.d.paths.worktreesDir, repo.name, dir);
+    const { id, dir } = freeSlot(join36(this.d.paths.worktreesDir, repo.name));
+    const wtPath = join36(this.d.paths.worktreesDir, repo.name, dir);
     const branch = `toyon/${dir}`;
     await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--no-track", "-b", branch, wtPath, baseOf(repo)));
     const wt = {
@@ -38883,9 +39868,8 @@ class WorktreeService {
 `).indexOf(sha);
         return i < 0 ? null : `stash@{${i}}`;
       };
-      const carried = await git(repo.path, "ls-tree", "-r", "--name-only", `${sha}^3`);
-      const restored = (carried.ok ? carried.out.split(`
-`).filter(Boolean) : []).filter((p) => !existsSync38(join35(wt.path, p)));
+      const carried = await gitRaw(repo.path, "ls-tree", "-r", "-z", "--name-only", `${sha}^3`);
+      const restored = (carried.ok ? nulSplit(carried.out) : []).filter((p) => !existsSync38(join36(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -38922,9 +39906,9 @@ class WorktreeService {
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
     let slug = branchSlug(title) || "branch";
-    if (existsSync38(join35(this.d.paths.worktreesDir, repo.name, slug)))
+    if (existsSync38(join36(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
-    const wtPath = join35(this.d.paths.worktreesDir, repo.name, slug);
+    const wtPath = join36(this.d.paths.worktreesDir, repo.name, slug);
     await withRepoLock(repo.path, async () => {
       const out = (await listWorktrees(repo.path)).find((w) => w.branch === branch);
       if (out)
@@ -39293,8 +40277,11 @@ class WorktreeService {
     this.d.drafts?.drop(worktreeId);
   }
   async takeDown(wt, archive, reason) {
+    const out = this.ship.shippingOf(wt.id);
+    if (out)
+      throw new UserError(`${shipNoun(out.op)} is still running in ${wt.title}; try again once it ends`);
     this.going.add(wt.id);
-    this.syncQueued.delete(wt.id);
+    this.ship.forget(wt.id);
     try {
       return await this.removeAndRecord(wt, archive, reason);
     } finally {
@@ -39308,7 +40295,7 @@ class WorktreeService {
     await this.teardown(wt, repo);
     const kept = await withRepoLock(repo.path, async () => {
       const k = archive ? await this.keep(repo, wt) : null;
-      if (archive && !k)
+      if (archive && (!k || k.lost))
         throw new UserError(`could not keep ${wt.title}'s work, so it was left in place`);
       if (archive)
         this.keepPlans(wt);
@@ -39367,12 +40354,12 @@ class WorktreeService {
     }
   }
   async keep(repo, wt) {
-    const index = join35(this.d.paths.archiveDir, `${wt.id}.index`);
+    const index = join36(this.d.paths.archiveDir, `${wt.id}.index`);
     const kept = await keepState(repo.path, wt.path, archiveRef(wt.id), index) ?? await this.keepUnlinked(repo, wt);
     if (!kept)
       log.warn(wt.id, "could not keep its git state");
     else if (kept.lost)
-      log.warn(wt.id, "could not keep its uncommitted changes: only its commits are archived");
+      log.warn(wt.id, "could not keep its uncommitted changes");
     return kept;
   }
   async keepUnlinked(repo, wt) {
@@ -39404,10 +40391,10 @@ class WorktreeService {
       log.warn(wt.id, `its directory could not be deleted and stays at ${wt.path}`);
   }
   plansScratch(worktreeId) {
-    return join35(this.d.paths.archiveDir, `${worktreeId}.plans`);
+    return join36(this.d.paths.archiveDir, `${worktreeId}.plans`);
   }
   keepPlans(wt) {
-    const from = join35(wt.path, PLANS_DIR);
+    const from = join36(wt.path, PLANS_DIR);
     if (!existsSync38(from))
       return;
     try {
@@ -39555,7 +40542,7 @@ class WorktreeService {
   }
   archivedAttachment(archiveId, file) {
     const files = this.archive.chatFiles(archiveId);
-    return files && isAttachmentFile(file) ? join35(files.attachments, file) : null;
+    return files && isAttachmentFile(file) ? join36(files.attachments, file) : null;
   }
   archivedGit(archiveId) {
     const rec = this.archive.get(archiveId);
@@ -39616,7 +40603,7 @@ class WorktreeService {
       throw new UserError(`${old.title} was archived without its commits, so there is nothing to restore`);
     if (rec.auto)
       log.info(old.id, `restoring a worktree that archived itself (${rec.auto})`);
-    const path = existsSync38(old.path) ? join35(dirname15(old.path), freeSlot(dirname15(old.path)).dir) : old.path;
+    const path = existsSync38(old.path) ? join36(dirname15(old.path), freeSlot(dirname15(old.path)).dir) : old.path;
     const wt = {
       ...old,
       repoId: repo.id,
@@ -39656,7 +40643,7 @@ class WorktreeService {
     run.finish(0);
     this.arriving.delete(wt.id);
     wt.branch = branch;
-    move(chat.plans, join35(path, PLANS_DIR));
+    move(chat.plans, join36(path, PLANS_DIR));
     const dropped = await git(repo.path, "update-ref", "-d", archiveRef(old.id));
     if (!dropped.ok)
       log.warn(old.id, `could not drop its archive ref: ${dropped.err}`);
@@ -39795,6 +40782,9 @@ class WorktreeService {
         throw new UserError("worktrees must belong to one repo");
       if (isBusy(this.d.runtime.agentFor(w.id)?.status))
         throw new UserError(`${w.title}'s agent is mid-turn; stop it first`);
+      const out = this.ship.shippingOf(w.id);
+      if (out)
+        throw new UserError(`${shipNoun(out.op)} is still running in ${w.title}; try again once it ends`);
     }
     for (const w of all) {
       if ((await statusFiles(w.path)).length > 0)
@@ -39817,7 +40807,7 @@ class WorktreeService {
     }
     for (const w of sources)
       await this.discardWorktree(w.id);
-    await this.refreshLanded(target);
+    await this.ship.refreshLanded(target);
     await this.headMoved(target.id);
     return { target, grafted: sources.map((w) => w.title) };
   }
@@ -39857,7 +40847,7 @@ class WorktreeService {
     }
   }
   async mirrorBaseIgnore(repo) {
-    const src = join35(repo.path, ".gitignore");
+    const src = join36(repo.path, ".gitignore");
     const tracked = existsSync38(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
     const mirror = existsSync38(src) && !tracked;
     const lines = mirror ? readFileSync22(src, "utf8").split(`
@@ -39875,8 +40865,8 @@ class WorktreeService {
       await this.d.cache.restore(wt, repo, (line) => this.d.hub.emit("log", wt.id, "setup", line));
       run.finish(0);
     }
-    const srcNm = join35(depsSource, "node_modules");
-    const dstNm = join35(wt.path, "node_modules");
+    const srcNm = join36(depsSource, "node_modules");
+    const dstNm = join36(wt.path, "node_modules");
     if (existsSync38(srcNm) && !existsSync38(dstNm)) {
       const run = this.runs.begin(wt.id, "setup", { timeoutMs: ceiling, stage: "copying dependencies" });
       const r = await cloneTree(srcNm, dstNm);
@@ -39887,10 +40877,10 @@ class WorktreeService {
         log.warn(wt.id, "could not copy node_modules from the base checkout", r.error);
     }
     for (const f of LOCAL_CONFIG_FILES) {
-      const src = join35(depsSource, f);
-      if (!existsSync38(src) || existsSync38(join35(wt.path, f)))
+      const src = join36(depsSource, f);
+      if (!existsSync38(src) || existsSync38(join36(wt.path, f)))
         continue;
-      const r = await run("cp", [src, join35(wt.path, f)], wt.path);
+      const r = await run("cp", [src, join36(wt.path, f)], wt.path);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `copied ${f}`);
       else
@@ -39913,188 +40903,31 @@ class WorktreeService {
       await this.d.runtime.start(wt, repo);
   }
   setPr(worktreeId, pr) {
-    const wt = this.d.state.worktree(worktreeId);
-    if (!wt || wt.pr === undefined && pr === undefined)
-      return;
-    if (pr)
-      wt.pr = pr;
-    else
-      delete wt.pr;
-    this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
-  }
-  async refreshLanded(wt, facts) {
-    if (wt.kind === "main")
-      return;
-    const f = facts ?? await this.landedFacts(wt);
-    if (f)
-      this.setLanded(wt, landedNow(wt, f));
-  }
-  async settleLanded(wt) {
-    const repo = this.d.state.repo(wt.repoId);
-    const f = wt.kind === "main" || !repo ? null : await this.landedFacts(wt);
-    delete wt.landing;
-    let held;
-    if (f && repo) {
-      held = notLandedWhy(wt, f, baseOf(repo));
-      if (held) {
-        delete wt.landed;
-        log.warn(wt.id, `landed, but not marked landed: ${held}`);
-      } else
-        wt.landed = true;
-    }
-    this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
-    return held;
-  }
-  async landedFacts(wt) {
-    const repo = this.d.state.repo(wt.repoId);
-    if (!repo)
-      return null;
-    try {
-      const [head, ab] = await Promise.all([git(wt.path, "rev-parse", "HEAD"), aheadBehind(wt.path, baseOf(repo))]);
-      if (!head.ok)
-        return null;
-      return { head: head.out, ahead: ab.ahead };
-    } catch (e) {
-      log.warn(wt.id, "could not read the tree for the landed mark", e);
-      return null;
-    }
-  }
-  setLanded(wt, landed) {
-    if (!!wt.landed === landed)
-      return;
-    if (landed)
-      wt.landed = true;
-    else
-      delete wt.landed;
-    this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
-  }
-  fingerprint(path) {
-    return (this.d.fingerprint ?? treeFingerprint)(path);
+    this.ship.setPr(worktreeId, pr);
   }
   setLanding(worktreeId, landing) {
-    const wt = this.d.state.worktree(worktreeId);
-    if (!wt || wt.landing === undefined && landing === undefined)
-      return;
-    if (landing)
-      wt.landing = landing;
-    else
-      delete wt.landing;
-    this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
+    this.ship.setLanding(worktreeId, landing);
   }
-  landable(worktreeId, verb) {
-    const pair = this.d.state.requireWorktreeWithRepo(worktreeId);
-    if (isMain(pair.wt))
-      throw new UserError(`${verb} from a worktree, not main`);
-    if (!canLand(pair.wt))
-      throw new UserError(`${pair.wt.title} is a PR under review; it lands upstream, not here`);
-    return pair;
+  land(worktreeId, message) {
+    return this.ship.land(worktreeId, message);
   }
-  commitMessage(wt, typed) {
-    const m = typed?.trim();
-    if (m)
-      return m;
-    const s = wt.landing?.subject;
-    if (s)
-      return wt.landing?.body ? `${s}
-
-${wt.landing.body}` : s;
-    throw new UserError("no commit message yet: write one in the changes panel");
+  prMerged(worktreeId) {
+    return this.ship.prMerged(worktreeId);
   }
-  async commitIfDirty(wt, typed) {
-    if ((await statusFiles(wt.path)).length === 0)
-      return null;
-    return this.commitRecorded(wt, this.commitMessage(wt, typed));
-  }
-  async commitRecorded(wt, message) {
-    const result = await commitWorktree(wt.path, message, this.landWatch(wt));
-    if (result.ok) {
-      await this.verdictSurvives(wt, { dropMessage: true });
-      await this.headMoved(wt.id);
-    }
-    return result;
+  sync(worktreeId, by = "press") {
+    return this.ship.sync(worktreeId, by);
   }
-  landWatch(wt) {
-    const repo = this.d.state.requireRepo(wt.repoId);
-    return {
-      step: (name) => this.step(wt.id, name),
-      git: async (cwd, args) => {
-        const where = cwd === wt.path ? "git" : `git -C ${cwd}`;
-        const commit = args[0] === "commit";
-        const ceiling = commit ? timeoutFor(repo.config, "commit") : STEP_TIMEOUT_MS;
-        const handle = commit ? this.runs.begin(wt.id, "commit", { timeoutMs: ceiling }) : null;
-        const run = (onText, signal) => stepRun(cwd, args, onText, signal, {
-          timeoutMs: ceiling,
-          ...handle ? { onSpawn: handle.spawned } : {},
-          onHook: (hook) => handle?.stage(hook ? `${hook} hook` : undefined)
-        });
-        const watched = async () => {
-          if (!this.d.watch)
-            return run(() => {});
-          const command = `${where} ${commandLine(args)}`;
-          try {
-            return { ...await this.d.watch(wt.id, command, run), command };
-          } catch (e) {
-            log.warn(wt.id, `landing step runs unwatched: ${e instanceof Error ? e.message : e}`);
-            return run(() => {});
-          }
-        };
-        const r = await watched();
-        handle?.finish(r.exit);
-        return r;
-      }
-    };
+  unqueueSync(worktreeId) {
+    this.ship.unqueueSync(worktreeId);
   }
-  async verdictSurvives(wt, opts) {
-    const l = wt.landing;
-    if (!l || l.check === "pending")
-      return;
-    const { subject, body, unanswered, ...kept } = l;
-    const message = opts.dropMessage ? {} : { ...subject ? { subject } : {}, ...body ? { body } : {}, ...unanswered ? { unanswered } : {} };
-    this.setLanding(wt.id, { ...kept, ...message, fingerprint: await this.fingerprint(wt.path) });
+  pull(worktreeId) {
+    return this.ship.pull(worktreeId);
   }
-  async landedByHand(wt, mark) {
-    const repo = this.d.state.requireRepo(wt.repoId);
-    log.info(wt.id, `landed on ${baseOf(repo)} outside toyon: ${mark.base.slice(0, 7)}..${mark.tip.slice(0, 7)}`);
-    await this.noteLand(repo, wt, mark);
-    await this.restartFromMain(wt, baseOf(repo));
-    await this.settleLanded(wt);
-    this.d.hub.emit("landed", wt.id);
+  commit(worktreeId, message) {
+    return this.ship.commit(worktreeId, message);
   }
-  async land(worktreeId, message) {
-    const { wt, repo } = this.landable(worktreeId, "land");
-    const out = await this.ship(wt.id, "land", async () => {
-      await this.followBranch(wt);
-      const moved = await this.movedMidTurn(wt);
-      if (moved)
-        return { result: moved };
-      return this.landOp(wt, repo, message);
-    });
-    if (out.result.ok && out.landed) {
-      this.noteLanded(wt, out.result.message, out);
-      this.markPrompted(wt.id);
-    }
-    return { result: this.fixShip(wt, out.result, baseOf(repo)) };
-  }
-  fixShip(wt, result, base) {
-    if (result.ok)
-      return result;
-    if (result.hook?.name === "commit-msg") {
-      this.d.hub.emit("messageRefused", wt.id, result.hook.text.trim().slice(-REFUSAL_CHARS));
-      return { ...result, message: "the commit-msg hook refused the message: another is being written" };
-    }
-    const { hook } = result;
-    const failure = hook ? { kind: "hook", hook: hook.name, toolId: hook.toolId, command: hook.command, text: hook.text } : result.conflict ? {
-      kind: "conflict",
-      base,
-      how: result.conflict,
-      ...result.step ? { step: result.step } : {},
-      ...result.carried ? { carried: result.carried } : {}
-    } : null;
-    return failure && this.d.fix.report(wt.id, failure) ? { ...result, asked: true } : result;
+  shippingOf(id) {
+    return this.ship.shippingOf(id);
   }
   async fixPreview(worktreeId, clientId) {
     const wt = this.d.state.requireWorktree(worktreeId);
@@ -40113,439 +40946,6 @@ ${wt.landing.body}` : s;
       ...isProvisional(wt) ? { worktreeId } : {}
     });
   }
-  async movedMidTurn(wt) {
-    if (!isBusy(this.d.runtime.agentFor(wt.id)?.status))
-      return null;
-    const l = wt.landing;
-    if (!l || l.fingerprint === await this.fingerprint(wt.path))
-      return null;
-    return { ok: false, message: "the agent has changed files since the check: land once its turn ends" };
-  }
-  noteLanded(wt, message, o) {
-    this.d.runtime.ensureAgent(wt).agent.note({
-      type: "landed",
-      message,
-      ...o.mark ? { mark: o.mark } : {},
-      ...o.url ? { url: o.url } : {},
-      ...o.held ? { held: o.held } : {},
-      ts: Date.now()
-    });
-    this.d.hub.emit("landed", wt.id);
-  }
-  async followBranch(wt, current) {
-    if (wt.kind === "main")
-      return;
-    const branch = current ?? (await git(wt.path, "branch", "--show-current")).out;
-    if (!branch || branch === wt.branch)
-      return;
-    log.info(wt.id, `on ${branch} now, not ${wt.branch}: the row follows the checkout`);
-    wt.branch = branch;
-    this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
-  }
-  shippingOf(id) {
-    return this.ops.get(id);
-  }
-  async ship(id, op, run) {
-    const out = this.ops.get(id);
-    if (out)
-      throw new UserError(`${shipNoun(out.op)} is already running here`);
-    const release = this.d.runtime.agentFor(id)?.hold();
-    this.ops.set(id, { op });
-    this.d.hub.emit("worktreesChanged");
-    const started = Date.now();
-    const watchdog = setInterval(() => {
-      const step = this.ops.get(id)?.step;
-      const at = step ? ` at "${step}"` : "";
-      log.warn(id, `${shipNoun(op)} still running after ${describeDuration(Date.now() - started)}${at}`);
-    }, RUN_CEILING_MS);
-    watchdog.unref?.();
-    try {
-      return await run();
-    } finally {
-      clearInterval(watchdog);
-      this.ops.delete(id);
-      release?.();
-      this.d.hub.emit("worktreesChanged");
-      if (!isBusy(this.d.runtime.agentFor(id)?.status))
-        this.syncAfterTurn(id);
-    }
-  }
-  step(id, name) {
-    const out = this.ops.get(id);
-    if (!out || out.step === name)
-      return;
-    out.step = name;
-    this.d.hub.emit("worktreesChanged");
-  }
-  async landOp(wt, repo, message) {
-    const policy = landPolicy(repo.config);
-    const own = hasOwnBranch(wt);
-    const w = this.landWatch(wt);
-    const typed = message?.trim();
-    const suggested = typed || (wt.landing?.subject ? wt.landing.body ? `${wt.landing.subject}
-
-${wt.landing.body}` : wt.landing.subject : undefined);
-    const base = baseOf(repo);
-    if (policy.land === "pr") {
-      if (wt.pr?.state === "merged" && !prTaken(wt)) {
-        const { mark, held, ...result } = await this.prMergedOp(wt.id, undefined, w);
-        return result.ok ? { result, landed: true, mark, held, url: wt.pr.url } : { result };
-      }
-      const fetched = await this.fetchBase(wt, repo, w);
-      if (!fetched.ok)
-        return { result: fetched };
-      if (wt.pr?.state === "open") {
-        const dirty = (await statusFiles(wt.path)).length > 0;
-        const missing = dirty || (await aheadUpstream(wt.path, wt.branch) ?? 0) > 0;
-        if (!missing) {
-          const result = await mergePr(wt.path, wt.pr.number, policy.merge, w);
-          if (result.ok && result.queued)
-            this.setPr(wt.id, { ...wt.pr, queue: true, queued: "waiting", at: Date.now() });
-          return { result };
-        }
-        const committed = await this.commitIfDirty(wt, message);
-        if (committed && !committed.ok)
-          return { result: committed };
-        this.tree.invalidate(wt.id);
-        const taken = await takeMainIn(wt.path, base, own, w);
-        if (!taken.ok)
-          return { result: taken };
-        await this.headMoved(wt.id);
-        this.tree.invalidate(wt.id);
-        const pushed = await pushBranch(wt.path, wt.branch, w);
-        if (!pushed.ok)
-          return { result: pushed };
-        await this.headMoved(wt.id);
-        this.setLanding(wt.id, undefined);
-        this.markPrompted(wt.id);
-        const did = committed ? "committed and pushed" : "pushed";
-        if (wt.pr.queued) {
-          const { queued: _, ...left } = wt.pr;
-          this.setPr(wt.id, { ...left, at: Date.now() });
-          return {
-            result: {
-              ok: true,
-              url: wt.pr.url,
-              message: `${did}; PR #${wt.pr.number} has the new commits and left the merge queue: land it again once it is ready`
-            }
-          };
-        }
-        return { result: { ok: true, url: wt.pr.url, message: `${did}; PR #${wt.pr.number} has the new commits` } };
-      }
-      const committed = await this.commitIfDirty(wt, message);
-      if (committed && !committed.ok)
-        return { result: committed };
-      const mark = await landingMark(wt.path, base);
-      this.tree.invalidate(wt.id);
-      const taken = await takeMainIn(wt.path, base, own, w);
-      if (!taken.ok)
-        return { result: taken };
-      await this.headMoved(wt.id);
-      if ((await aheadBehind(wt.path, base)).ahead === 0) {
-        const { mark: noted, held, ...r } = await this.prMergedOp(wt.id, mark, w);
-        const on = `origin's ${repo.defaultBranch} has this work already`;
-        const result = { ...r, message: r.ok ? `${on}; ${r.message}` : `${on}, but ${r.message}` };
-        return r.ok ? { result, landed: true, mark: noted, held, url: wt.pr?.url } : { result };
-      }
-      const named = !suggested ? undefined : splitMessage(policy.merge === "squash" ? await squashMessage(wt.path, base, suggested, !!typed) : suggested);
-      const result = await openPr({
-        worktreePath: wt.path,
-        branch: wt.branch,
-        defaultBr: repo.defaultBranch,
-        base,
-        subject: named?.subject,
-        body: named?.body,
-        automerge: policy.automerge,
-        method: policy.merge
-      }, w);
-      if (result.ok) {
-        this.setLanding(wt.id, undefined);
-        if (result.pr)
-          this.setPr(wt.id, { ...result.pr, at: Date.now() });
-        this.markPrompted(wt.id);
-      }
-      return { result };
-    }
-    if (policy.land === "push")
-      return this.landPush(wt, repo, policy, message, suggested, w);
-    let mergedHere = false;
-    let committedHere = false;
-    let held;
-    let noted;
-    const result = await withRepoLock(repo.path, async () => {
-      const committed = await this.commitIfDirty(wt, message);
-      if (committed && !committed.ok)
-        return committed;
-      committedHere = committed !== null;
-      const method = policy.merge ?? DEFAULT_MERGE_METHOD;
-      const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
-      if (merged)
-        return merged;
-      const taken = await takeMainIn(wt.path, base, own, w);
-      if (!taken.ok)
-        return taken;
-      const mark = await landingMark(wt.path, base);
-      const squash = method === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : "";
-      const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash, w);
-      if (!landed.ok)
-        return landed;
-      mergedHere = true;
-      noted = await this.noteLand(repo, wt, mark, { squash });
-      await this.restartFromMain(wt, base);
-      return landed;
-    });
-    if (mergedHere) {
-      this.invalidateCounts();
-      held = await this.settleLanded(wt);
-    }
-    if (!result.ok)
-      return { result };
-    const did = committedHere ? "committed and merged" : "merged";
-    return {
-      result: { ...result, message: `${did} into ${repo.defaultBranch}` },
-      landed: true,
-      mark: noted,
-      held
-    };
-  }
-  async landPush(wt, repo, policy, message, suggested, w) {
-    const base = baseOf(repo);
-    const own = hasOwnBranch(wt);
-    const method = policy.merge ?? DEFAULT_MERGE_METHOD;
-    const committed = await this.commitIfDirty(wt, message);
-    if (committed && !committed.ok)
-      return { result: committed };
-    const read = await landingMark(wt.path, base);
-    if (!read)
-      return { result: { ok: false, message: `nothing to land: no commits ahead of ${base}` } };
-    let sha = "";
-    let already = false;
-    let squash = "";
-    const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
-    if (merged)
-      return { result: merged };
-    for (let attempt = 0;; attempt++) {
-      const fetched = await this.fetchBase(wt, repo, w);
-      if (!fetched.ok)
-        return { result: fetched };
-      this.tree.invalidate(wt.id);
-      const taken = await takeMainIn(wt.path, base, own, w);
-      if (!taken.ok)
-        return { result: taken };
-      await this.headMoved(wt.id);
-      if ((await aheadBehind(wt.path, base)).ahead === 0) {
-        already = true;
-        sha = await commitOf(wt.path, base) ?? "";
-        break;
-      }
-      squash = method === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : "";
-      this.tree.invalidate(wt.id);
-      const built = await landingCommit(wt.path, wt.branch, base, method, squash, own, w);
-      await this.headMoved(wt.id);
-      if (!built.ok || !built.sha)
-        return { result: built };
-      sha = built.sha;
-      const pushed = await pushLanding(wt.path, sha, repo.defaultBranch, w);
-      if (pushed.ok)
-        break;
-      if (!pushed.moved)
-        return { result: pushed };
-      if (attempt > 0) {
-        return { result: { ok: false, message: `${base} moved twice while this landed; land again` } };
-      }
-    }
-    if (await commitOf(wt.path, base) !== sha)
-      await this.fetchBase(wt, repo, w);
-    let noted;
-    await withRepoLock(repo.path, async () => {
-      noted = await this.noteLand(repo, wt, read, { squash });
-      await this.restartFromMain(wt, base);
-    });
-    this.invalidateCounts();
-    const held = await this.settleLanded(wt);
-    const followed = await this.trunk.catchUp(repo.id);
-    const here = followed.ok ? `${repo.defaultBranch} here ${followed.moved ? "pulled it" : "has it"}` : `${repo.defaultBranch} here was left where it is: ${followed.message}`;
-    const how = { merge: "merged into", squash: "squashed onto", rebase: "rebased onto" }[method];
-    const did = already ? `origin's ${repo.defaultBranch} has this work already` : `${committed ? `committed and ${how}` : how} ${repo.defaultBranch} and pushed`;
-    return { result: { ok: true, message: `${did}; ${here}` }, landed: true, mark: noted, held };
-  }
-  async noteLand(repo, wt, mark, opts = {}) {
-    if (!mark)
-      return;
-    const n = wt.lands?.length ?? 0;
-    const pinned = await git(repo.path, "update-ref", landRef(wt.id, n), mark.tip);
-    if (!pinned.ok) {
-      log.warn(wt.id, `could not keep the commits it landed: ${pinned.err}`);
-      return;
-    }
-    const noted = {
-      ...mark,
-      at: Date.now(),
-      ...opts.pr ? { pr: opts.pr.number } : {},
-      subjects: await this.landedWhat(repo, wt, mark, opts)
-    };
-    wt.lands = [...wt.lands ?? [], noted];
-    this.d.state.save();
-    return noted;
-  }
-  async landedWhat(repo, wt, mark, opts) {
-    if (opts.pr?.title)
-      return [opts.pr.title];
-    const subject = opts.squash ? splitMessage(opts.squash).subject : "";
-    if (subject)
-      return [subject];
-    const read = await rangeSubjects(repo.path, mark.base, mark.tip);
-    if (!read)
-      log.warn(wt.id, `could not read what it landed: ${mark.base.slice(0, 7)}..${mark.tip.slice(0, 7)}`);
-    return read ?? [];
-  }
-  async tipMark(wt) {
-    const head = await git(wt.path, "rev-parse", "HEAD");
-    return head.ok ? { base: head.out, tip: head.out } : null;
-  }
-  async restartFromMain(wt, base) {
-    if (!hasOwnBranch(wt))
-      return;
-    this.tree.invalidate(wt.id);
-    const r = await git(wt.path, "reset", "--keep", base);
-    if (!r.ok)
-      log.warn(wt.id, `could not restart ${wt.branch} from ${base}: ${r.err}`);
-    await this.tree.refresh(wt.id);
-  }
-  async fetchBase(wt, repo, w) {
-    if (!baseIsRemote(repo))
-      return { ok: true, message: `${baseOf(repo)} here is the base` };
-    const r = await withFetchLock(repo.path, () => fetchBase(wt.path, repo, w));
-    this.trunk.noteFetch(repo.id, { ok: r.ok, err: r.message });
-    return r;
-  }
-  async prMerged(worktreeId) {
-    const wt = this.d.state.worktree(worktreeId);
-    const pr = wt?.pr ? `PR #${wt.pr.number}` : "the PR";
-    const out = this.ops.get(worktreeId);
-    if (out) {
-      const message = `${shipNoun(out.op)} is already running here`;
-      log.info(worktreeId, `${pr} merged on GitHub; ${message}, landing waits`);
-      return { ok: false, message };
-    }
-    if (wt && prTaken(wt))
-      return { ok: true, message: `${pr} merged; landed already` };
-    log.info(worktreeId, `${pr} merged on GitHub; landing it`);
-    const { mark, held, ...result } = await this.ship(worktreeId, "land", () => this.prMergedOp(worktreeId));
-    if (result.ok)
-      log.info(worktreeId, `landed: ${result.message}`);
-    else
-      log.warn(worktreeId, `landing failed: ${result.message}`);
-    if (result.ok && wt)
-      this.noteLanded(wt, result.message, { mark, url: wt.pr?.url, held });
-    return result;
-  }
-  async prMergedOp(worktreeId, carried, w = UNWATCHED) {
-    const { wt, repo } = this.d.state.requireWorktreeWithRepo(worktreeId);
-    const br = repo.defaultBranch;
-    const base = baseOf(repo);
-    const read = carried === undefined ? await landingMark(wt.path, base) : carried;
-    const pulled = await this.trunk.pull(repo.id, w);
-    let noted;
-    await withRepoLock(repo.path, async () => {
-      if (!prTaken(wt)) {
-        const own = read ?? await handLanding(wt.path, wt.branch, base, wt.lands?.at(-1)?.tip);
-        const mark = own ?? (wt.pr ? await this.tipMark(wt) : null);
-        noted = await this.noteLand(repo, wt, mark, { pr: wt.pr });
-      }
-      await this.restartFromMain(wt, base);
-    });
-    this.invalidateCounts();
-    const held = await this.settleLanded(wt);
-    const took = pulled.ok ? `${br} here ${pulled.moved ? "pulled it" : "has it"}` : `${br} here was left where it is: ${pulled.message}`;
-    return { ok: true, message: wt.pr ? `PR #${wt.pr.number} merged; ${took}` : took, mark: noted, held };
-  }
-  async sync(worktreeId) {
-    const r = this.readable(worktreeId);
-    if (!r)
-      throw new UserError("that worktree is gone");
-    if (r.wt && isMain(r.wt))
-      throw new UserError("sync from a worktree, not main");
-    if (r.wt && isProvisional(r.wt))
-      throw new UserError("the new worktree already sits on main; it follows it on its own");
-    if (!r.branch)
-      throw new UserError(`${r.name} is detached: check out a branch in it first`);
-    if (r.locked)
-      throw new UserError(`${r.name} is held by another tool`);
-    const repo = this.d.state.requireRepo(r.repoId);
-    const own = r.wt ? hasOwnBranch(r.wt) : false;
-    const carry = !!r.wt;
-    const busy = isBusy(this.d.runtime.agentFor(worktreeId)?.status);
-    if (carry && busy && (await statusFiles(r.path)).length > 0) {
-      this.syncQueued.add(worktreeId);
-      this.d.hub.emit("worktreesChanged");
-      return { result: { ok: true, message: `${r.name} syncs from ${r.base} once the turn ends` }, base: r.base };
-    }
-    const w = r.wt ? this.landWatch(r.wt) : UNWATCHED;
-    const result = await this.ship(worktreeId, "sync-main", async () => {
-      if (r.wt) {
-        const fetched = await this.fetchBase(r.wt, repo, w);
-        if (!fetched.ok)
-          return fetched;
-      }
-      this.tree.invalidate(worktreeId);
-      const taken = await withRepoLock(repo.path, () => takeMainIn(r.path, r.base, own, w, carry));
-      if (taken.ok) {
-        await this.headMoved(worktreeId);
-        if (r.wt)
-          await this.verdictSurvives(r.wt, { dropMessage: false });
-      }
-      return taken;
-    });
-    return { result: r.wt ? this.fixShip(r.wt, result, r.base) : result, base: r.base };
-  }
-  unqueueSync(worktreeId) {
-    if (!this.syncQueued.delete(worktreeId))
-      return;
-    this.d.hub.emit("worktreesChanged");
-  }
-  syncAfterTurn(worktreeId) {
-    if (!this.syncQueued.has(worktreeId))
-      return;
-    if (this.ops.has(worktreeId))
-      return;
-    this.syncQueued.delete(worktreeId);
-    const release = this.d.runtime.agentFor(worktreeId)?.hold();
-    this.d.hub.emit("worktreesChanged");
-    fireAndForget(worktreeId, (async () => {
-      try {
-        const { result } = await this.sync(worktreeId);
-        if (!result.ok && !result.asked)
-          this.d.hub.emit("failed", worktreeId, result.message);
-      } catch (e) {
-        this.d.hub.emit("failed", worktreeId, e instanceof Error ? e.message : String(e));
-      } finally {
-        release?.();
-      }
-    })(), "sync after the turn");
-  }
-  async pull(worktreeId) {
-    const wt = this.d.state.requireWorktree(worktreeId);
-    if (!isMain(wt))
-      throw new UserError("pull on main; a worktree syncs from main instead");
-    const repo = this.d.state.requireRepo(wt.repoId);
-    const w = { step: (name) => this.step(worktreeId, name), git: UNWATCHED.git };
-    return this.ship(worktreeId, "pull-main", async () => {
-      const result = await this.trunk.pull(repo.id, w);
-      if (result.ok && result.moved)
-        await this.recountAll();
-      return result;
-    });
-  }
-  async commit(worktreeId, message) {
-    const wt = this.d.state.requireWorktree(worktreeId);
-    const m = message.trim();
-    if (!m)
-      throw new UserError("commit message required");
-    const base = baseOf(this.d.state.requireRepo(wt.repoId));
-    return this.fixShip(wt, await this.ship(wt.id, "commit", () => this.commitRecorded(wt, m)), base);
-  }
   setEmpty(wt, empty) {
     if (wt.empty === empty)
       return;
@@ -40559,7 +40959,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
   trunksNow() {
     const all = this.trunk.all();
     for (const t of Object.values(all)) {
-      const shipping = this.ops.get(t.id);
+      const shipping = this.ship.shippingOf(t.id);
       if (shipping)
         t.shipping = shipping;
     }
@@ -40736,37 +41136,12 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
     const wt = r.wt;
     if (!wt)
       return false;
-    if (this.ops.has(wt.id))
+    if (this.ship.shippingOf(wt.id))
       return false;
-    const isMain = wt.kind === "main";
-    if (core.branch)
-      await this.followBranch(wt, core.branch);
-    const { files, head } = core;
-    const ahead = core.ahead ?? 0;
-    if (!isMain && hasOwnBranch(wt) && files.length === 0 && ahead === 0 && head && this.handChecked.get(wt.id) !== head) {
-      this.handChecked.set(wt.id, head);
-      const mark = await handLanding(r.path, wt.branch, r.base, wt.lands?.at(-1)?.tip);
-      if (mark) {
-        await this.landedByHand(wt, mark);
-        return true;
-      }
-    }
-    if (!isMain && head) {
-      const facts = { head, ahead };
-      if (prTaken(wt) && movedPastLand(wt, facts))
-        this.setPr(wt.id, undefined);
-      await this.refreshLanded(wt, facts);
-    }
-    const landing = wt.landing;
-    if (landing && landing.check !== "pending") {
-      const moved = landing.fingerprint !== await this.fingerprint(r.path);
-      if (wt.landing === landing && moved !== !!landing.stale) {
-        const { stale: _was, ...rest } = landing;
-        this.setLanding(wt.id, moved ? { ...rest, stale: true } : rest);
-      }
-    }
-    if (isMain)
-      this.setEmpty(wt, files.length === 0 ? await treeEmpty(r.path) : false);
+    if (await this.ship.afterRead(r, wt, core))
+      return true;
+    if (wt.kind === "main")
+      this.setEmpty(wt, core.files.length === 0 ? await treeEmpty(r.path) : false);
     return false;
   }
   async gitStatus(worktreeId) {
@@ -40836,12 +41211,16 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
     this.markPrompted(worktreeId);
   }
   markPrompted(worktreeId) {
+    if (this.stampPrompted(worktreeId))
+      this.d.hub.emit("worktreesChanged");
+  }
+  stampPrompted(worktreeId) {
     const wt = this.d.state.worktree(worktreeId);
     if (!wt)
-      return;
+      return false;
     wt.promptedAt = Date.now();
     this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
+    return true;
   }
   snapshot() {
     const rows = [...this.ownedRows(), ...this.foundRows()];
@@ -40929,8 +41308,8 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
         usage: this.usageFor(wt.id),
         transcript: this.writtenTranscript(wt.id),
         sessionId: this.d.state.session(wt.id),
-        shipping: this.ops.get(wt.id),
-        syncQueued: this.syncQueued.has(wt.id) || undefined
+        shipping: this.ship.shippingOf(wt.id),
+        syncQueued: this.ship.syncWaiting(wt.id) || undefined
       };
     });
   }
@@ -40945,7 +41324,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
         ahead,
         behind,
         dirty,
-        shipping: this.ops.get(f.id)
+        shipping: this.ship.shippingOf(f.id)
       };
     });
   }
@@ -41056,17 +41435,17 @@ if (pruned > 0)
 var managed = await loadManaged();
 var paths = makePaths();
 ensureDirs(paths);
-forwardTranscripts([paths.transcriptsDir, paths.archiveDir], join36(paths.home, "transcripts-forwarded"));
+forwardTranscripts([paths.transcriptsDir, paths.archiveDir], join37(paths.home, "transcripts-forwarded"));
 var token = loadOrCreateToken(paths);
 var port = Number(process.env.TOYON_PORT ?? DAEMON_DEFAULT_PORT);
-var helperApp = join36(paths.home, DAEMON_FILES.helper);
+var helperApp = join37(paths.home, DAEMON_FILES.helper);
 var helper = helperWanted({ platform: process.platform, cloud: cloud.enabled, port, home: process.env.TOYON_HOME }) ? new Helper({
   dir: helperApp,
   stub: HELPER_STUB,
   bun: process.execPath,
   cli: CLI_ENTRY,
-  log: join36(paths.home, DAEMON_FILES.launcherLog),
-  icon: join36(SHELL_DIST, "icon.svg"),
+  log: join37(paths.home, DAEMON_FILES.launcherLog),
+  icon: join37(SHELL_DIST, "icon.svg"),
   version: package_default.version
 }) : null;
 if (helper) {
@@ -41091,7 +41470,7 @@ var tailscale = tailscaleCli();
 var tailnet = new Tailnet({ ts: findTailscale() ? tailscale : null, hub });
 var remoteSwitch = new RemoteSwitch({ setting, ts: tailscale, port, file: paths.remoteFile, policy: managed.policy });
 var knocks = new Knocks(hub);
-var origins = new Origins({ setting, port, branded: () => branded });
+var origins = new Origins({ setting, port, branded: () => branded, appPorts: () => runtime.appPorts() });
 var linuxSandbox = new LinuxSandbox;
 await linuxSandbox.refresh();
 var agents = loadAgentRegistry(paths.agentsFile, paths.agentsDir, linuxSandbox, managed.policy, paths.agentsFrom);
@@ -41167,7 +41546,8 @@ var worktrees = new WorktreeService({
   fix,
   pageErrors: (id) => pageErrors.ambient(id),
   interested: (id) => interest.isSubscribed(id),
-  shown: (id) => idle.isShown(id)
+  shown: (id) => idle.isShown(id),
+  message: (wt) => landing.message(wt.id)
 });
 interest.onFirst((id) => worktrees.tree.watch(id));
 interest.onLast((id) => worktrees.tree.unwatch(id));