toyon 0.4.0 → 0.5.0

package/dist/daemon.js

@@ -1,7 +1,7 @@
 // @bun
 // ../daemon/src/index.ts
-import { rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname9 } from "path";
+import { rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname10 } from "path";
 import { fileURLToPath } from "url";
 
 // ../shared/src/agent-tools.ts
@@ -12,6 +12,16 @@ var WRITE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 function isWriteTool(ev) {
   return ev.kind ? WRITE_KINDS.has(ev.kind) : WRITE_TOOLS.has(ev.name);
 }
+var WRITTEN_KINDS = ["read", "edit", "delete", "move", "search", "execute", "fetch"];
+function isWrittenKind(kind) {
+  return WRITTEN_KINDS.includes(kind ?? "");
+}
+function emptyInput(input) {
+  if (!input || typeof input !== "object")
+    return true;
+  const rec = input;
+  return Object.keys(rec).every((k) => k === "locations" && Array.isArray(rec[k]) && rec[k].length === 0);
+}
 
 // ../shared/src/model.ts
 var DEFAULT_PERMISSION_MODE = "auto";
@@ -37,6 +47,12 @@ function streamKey(worktreeId, stream) {
 function isMain(wt) {
   return wt.kind === "main";
 }
+function isProvisional(wt) {
+  return wt.kind === "spare";
+}
+function isLead(wt) {
+  return isProvisional(wt) || isMain(wt);
+}
 function canArchive(wt) {
   return wt.kind === "worktree";
 }
@@ -52,8 +68,8 @@ function canGraft(wt) {
 
 // ../shared/src/railOrder.ts
 var sentAt = (w) => w.promptedAt ?? w.lastTurn?.at ?? w.createdAt;
-var tierOf = (w) => isMain(w) ? 0 : w.landed ? 2 : 1;
-var railUnitOf = (w) => w.variant ? `${tierOf(w)}:${w.variant.group}` : `row:${w.id}`;
+var tierOf = (w) => isLead(w) ? 0 : 1;
+var railUnitOf = (w) => w.variant ? `group:${w.variant.group}` : `row:${w.id}`;
 function railOrder(rows) {
   const units = [];
   const groups = new Map;
@@ -275,11 +291,6 @@ function middle(a, b) {
   return ops;
 }
 
-// ../shared/src/drafts.ts
-var DRAFT_PREFIX = "draft:";
-var draftKey = (repoId) => DRAFT_PREFIX + repoId;
-var draftRepoOf = (boxId) => boxId.startsWith(DRAFT_PREFIX) ? boxId.slice(DRAFT_PREFIX.length) : null;
-
 // ../shared/src/land.ts
 var DEFAULT_LAND_ROUTE = "merge";
 var DEFAULT_MERGE_METHOD = "merge";
@@ -297,7 +308,7 @@ var PAIR_TTL_MS = 120000;
 var pairLink = (host, code) => `https://${host}/#pair=${code}`;
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 58;
+var PROTOCOL_VERSION = 65;
 var FILE_MAX_CHARS = 5000000;
 var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var IMAGE_MAX_EDGE = 2576;
@@ -6384,6 +6395,7 @@ var clientMsgSchema = discriminatedUnion("t", [
     t: literal("create-worktree"),
     clientId: string2().max(64).optional(),
     repoId: id,
+    worktreeId: id.optional(),
     prompt,
     variant: variantSchema.optional(),
     context: ambient.optional(),
@@ -6432,6 +6444,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("run-after-land"), repoId: id }),
   object({ t: literal("restart-daemon") }),
   object({ t: literal("update-now") }),
+  object({ t: literal("check-update") }),
   object({ t: literal("pull-main"), worktreeId: id }),
   object({
     t: literal("write-file"),
@@ -6447,6 +6460,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("find-element"), worktreeId: id, seq, element: elementTraitsSchema }),
   object({ t: literal("design-scan"), worktreeId: id }),
   object({ t: literal("discard-file"), worktreeId: id, path: relPath }),
+  object({ t: literal("judge"), worktreeId: id }),
   object({ t: literal("reveal"), worktreeId: id, path: relPath.optional() }),
   object({ t: literal("stop-agent"), worktreeId: id }),
   object({ t: literal("seen"), worktreeId: id }),
@@ -6548,6 +6562,9 @@ function parseClientMsg(raw) {
   return { ok: false, reason: issueReason(r.error, "invalid message") };
 }
 
+// ../shared/src/restart.ts
+var RESTART_NOW = "now";
+
 // ../shared/src/routes.ts
 var BASE = "http://preview.invalid";
 var TITLE_MAX = 200;
@@ -7722,7 +7739,7 @@ function slug(s) {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.4.0",
+  version: "0.5.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -11840,11 +11857,18 @@ function fmtExtra(extra) {
     return ` ${String(extra)}`;
   }
 }
+var lastDay = "";
 function write(level, tag, message, extra) {
   if (LEVELS[level] < threshold)
     return;
-  const ts = new Date().toISOString().slice(11, 19);
-  process.stderr.write(`${ts} ${level.padEnd(5)} [${tag}] ${message}${fmtExtra(extra)}
+  const iso = new Date().toISOString();
+  const day = iso.slice(0, 10);
+  if (day !== lastDay) {
+    lastDay = day;
+    process.stderr.write(`-------- ${day} --------
+`);
+  }
+  process.stderr.write(`${iso.slice(11, 19)} ${level.padEnd(5)} [${tag}] ${message}${fmtExtra(extra)}
 `);
 }
 var log = {
@@ -12001,6 +12025,27 @@ async function within(p, ms) {
   clearTimeout(timer);
   return done;
 }
+var GONE_POLL_MS = 100;
+function groupGone(pgid) {
+  const deadline = Date.now() + KILL_GRACE_MS + EXIT_GRACE_MS + 500;
+  return new Promise((resolve) => {
+    const poll = () => {
+      try {
+        process.kill(-pgid, 0);
+      } catch (e) {
+        if (e.code === "ESRCH")
+          return resolve();
+      }
+      if (Date.now() >= deadline)
+        return resolve();
+      setTimeout(poll, GONE_POLL_MS).unref?.();
+    };
+    poll();
+  });
+}
+function reclaimGroup(pgid) {
+  return killGroup(pgid, groupGone(pgid));
+}
 
 // ../daemon/src/agent/acp/transport.ts
 function spawnAcp(app, launch, cwd, tag) {
@@ -12035,7 +12080,7 @@ function spawnAcp(app, launch, cwd, tag) {
     exitInfo = `agent process exited (${why})${tail ? `: ${tail}` : ""}`;
     conn.close(new Error(exitInfo));
   });
-  return { conn, kill: () => killProcessGroup(child), exited, exitInfo: () => exitInfo };
+  return { conn, pid: child.pid ?? null, kill: () => killProcessGroup(child), exited, exitInfo: () => exitInfo };
 }
 
 // ../daemon/src/agent/attachments.ts
@@ -12366,6 +12411,7 @@ var NO_PROMPT = {
   SSH_ASKPASS: "",
   GIT_SSH_COMMAND: "ssh -o BatchMode=yes"
 };
+var SPAWN_ENV = { GIT_OPTIONAL_LOCKS: "0" };
 async function run(cmd, args, cwd, env) {
   const started = Date.now();
   try {
@@ -12374,7 +12420,7 @@ async function run(cmd, args, cwd, env) {
       stdout: "pipe",
       stderr: "pipe",
       stdin: "ignore",
-      env: { ...process.env, ...env }
+      env: { ...process.env, ...SPAWN_ENV, ...env }
     });
     const [rawOut, err, status] = await Promise.all([
       new Response(p.stdout).text(),
@@ -12402,7 +12448,7 @@ async function runLive(cmd, args, cwd, opts = {}) {
       stdout: "pipe",
       stderr: "pipe",
       stdin: "ignore",
-      env: { ...process.env, ...opts.env }
+      env: { ...process.env, ...SPAWN_ENV, ...opts.env }
     });
     const stop = () => p.kill();
     opts.signal?.addEventListener("abort", stop, { once: true });
@@ -12694,6 +12740,29 @@ async function excludeFromGit(cwd, pattern) {
 ` : ""}${pattern}
 `);
 }
+async function excludeBlock(cwd, name, patterns) {
+  const file = await excludeFile(cwd);
+  if (!file)
+    return;
+  const open = `# toyon ${name}`;
+  const close = `# toyon end ${name}`;
+  const current = existsSync3(file) ? readFileSync3(file, "utf8") : "";
+  const lines = current.split(`
+`);
+  const from = lines.indexOf(open);
+  const to = lines.indexOf(close);
+  const kept = from >= 0 && to > from ? [...lines.slice(0, from), ...lines.slice(to + 1)] : lines;
+  while (kept.length > 0 && kept[kept.length - 1] === "")
+    kept.pop();
+  const next = [...kept, ...patterns.length > 0 ? [open, ...patterns, close] : []];
+  const text = next.length > 0 ? `${next.join(`
+`)}
+` : "";
+  if (text === current)
+    return;
+  mkdirSync2(dirname(file), { recursive: true });
+  writeFileSync(file, text);
+}
 async function unexcludeFromGit(cwd, pattern) {
   const file = await excludeFile(cwd);
   if (!file || !existsSync3(file))
@@ -13197,6 +13266,7 @@ var SYSTEM_APPEND = [
   "Never run `git push`, delete branches, or create pull requests; shipping is handled by the Toyon UI.",
   "Never run `git commit` unless the user explicitly asks you to; leave changes uncommitted for the user to review and commit themselves.",
   "Keep the scope tight: do the asked task well, then stop. Suggest follow-ups in chat instead of expanding scope.",
+  "When referencing a file in this worktree in chat, use a Markdown link whose target is its absolute path, with an optional `:line`; Toyon opens it in the built-in editor. A file outside the worktree has no page in Toyon: name its path in backticks instead of linking it.",
   "`@some/path` in a message means read that file or directory first; `@changes` means this worktree's uncommitted files, which `git status` lists.",
   `Toyon previews the project in a browser panel by running the commands in its settings file, .toyon/settings.json (or toyon.json at the repo root, in a repo that keeps it there), shaped like {"setup": ["bun install"], "run": {"web": "bun run dev --port $PORT"}, "check": "bun run check", "land": {"route": "merge"}}: setup runs once in every new worktree, every command in run keeps running and must listen on $PORT, which toyon sets differently for each worktree, check (optional) runs after each of your turns and must pass before the work can land, and land (optional) says how the user lands work on main: route "merge" (onto main here), "push" (onto main here, then pushed) or "pr" (a pull request); method "merge", "squash" or "rebase" for how the commits arrive on main; automerge true when GitHub should merge the pull request itself. A settings.local.json beside it (toyon.local.json at the root) holds one person's overrides and is never committed. Both files may carry comments and trailing commas; leave any you find.`,
   "Toyon runs those commands itself in every worktree, and the user watches the result live in a preview beside this chat, so never start a dev server or open a browser of your own to check your work. Each message says where this worktree's preview answers; fetch a page from there when you want to see it.",
@@ -13228,7 +13298,7 @@ function previewContext(p) {
       line = `The preview is running${at}, and the user sees it live beside this chat.`;
       break;
     case "asleep":
-      line = `The preview is asleep; it answers${at} once the user opens this worktree again.`;
+      line = `The preview is asleep${p.detail ? ` (${p.detail})` : ""}; it answers${at} once the user opens this worktree again.`;
       break;
     default:
       line = `The preview is ${p.status}${p.detail ? `: ${p.detail}` : ""}; nothing answers${at} until it is back.`;
@@ -13619,11 +13689,14 @@ function asRecord(v) {
   return v && typeof v === "object" && !Array.isArray(v) ? v : {};
 }
 var NETWORK_ASK = "SandboxNetworkAccess";
+function isNetworkAsk(update) {
+  return update.name === NETWORK_ASK || asRecord(asRecord(update._meta).claudeCode).toolName === NETWORK_ASK;
+}
 function heading(update) {
-  const name = update.name ?? update.title;
+  const name = typeof update.name === "string" ? update.name : "";
   const host = asRecord(update.rawInput).host;
-  if (name === NETWORK_ASK && typeof host === "string")
-    return { name: "network", title: host, kind: "fetch" };
+  if (isNetworkAsk(update) && typeof host === "string")
+    return { name: "", title: host, kind: "fetch" };
   return { name, title: update.title, ...update.kind ? { kind: update.kind } : {} };
 }
 function endOfAsk(req, res, memos) {
@@ -13641,40 +13714,59 @@ function endOfAsk(req, res, memos) {
     isError: !allowed
   };
 }
+function abandoned(memos, parent) {
+  const out = [];
+  for (const [toolId, memo] of memos) {
+    if (memo.ended || !memo.writing || memo.parent !== parent)
+      continue;
+    memo.ended = true;
+    out.push({ type: "tool-end", toolId });
+  }
+  return out;
+}
 function mapUpdate(update, memos, tag) {
   switch (update.sessionUpdate) {
     case "agent_message_chunk": {
+      const { parentToolId } = spawnOf(update._meta);
+      const out = abandoned(memos, parentToolId);
       const text = textOf(update.content, tag, "message");
       if (text === null)
-        return [];
-      const { parentToolId } = spawnOf(update._meta);
-      return [parentToolId ? { type: "tool-delta", toolId: parentToolId, text } : { type: "text-delta", text }];
+        return out;
+      out.push(parentToolId ? { type: "tool-delta", toolId: parentToolId, text } : { type: "text-delta", text });
+      return out;
     }
     case "agent_thought_chunk": {
-      if (spawnOf(update._meta).parentToolId)
-        return [];
+      const { parentToolId } = spawnOf(update._meta);
+      const out = abandoned(memos, parentToolId);
+      if (parentToolId)
+        return out;
       const text = textOf(update.content, tag, "thought");
-      return text === null ? [] : [{ type: "thinking-delta", text }];
+      if (text !== null)
+        out.push({ type: "thinking-delta", text });
+      return out;
     }
     case "tool_call": {
+      const spawn = spawnOf(update._meta);
+      const out = abandoned(memos, spawn.parentToolId);
+      const input = update.rawInput ?? { locations: update.locations ?? [] };
       const memo = {
         ...heading(update),
         content: update.content ?? [],
         rawOutput: update.rawOutput,
-        ended: false
+        ended: false,
+        writing: isWrittenKind(update.kind ?? undefined) && emptyInput(input),
+        ...spawn.parentToolId ? { parent: spawn.parentToolId } : {}
       };
       memos.set(update.toolCallId, memo);
-      const out = [
-        {
-          type: "tool-start",
-          toolId: update.toolCallId,
-          name: memo.name,
-          input: update.rawInput ?? { locations: update.locations ?? [] },
-          ...memo.kind ? { kind: memo.kind } : {},
-          title: memo.title,
-          ...spawnOf(update._meta)
-        }
-      ];
+      out.push({
+        type: "tool-start",
+        toolId: update.toolCallId,
+        name: memo.name,
+        input,
+        ...memo.kind ? { kind: memo.kind } : {},
+        title: memo.title,
+        ...spawn
+      });
       if (update.status === "completed" || update.status === "failed")
         out.push(endOf(update.toolCallId, memo, update.status));
       return out;
@@ -13683,37 +13775,45 @@ function mapUpdate(update, memos, tag) {
       let memo = memos.get(update.toolCallId);
       const out = [];
       if (!memo) {
+        const spawn = spawnOf(update._meta);
+        const input = update.rawInput ?? { locations: update.locations ?? [] };
         memo = {
-          name: update.name ?? update.title ?? "tool",
+          name: update.name ?? "",
           title: update.title ?? update.name ?? "tool",
           ...update.kind ? { kind: update.kind } : {},
           content: [],
-          ended: false
+          ended: false,
+          writing: isWrittenKind(update.kind ?? undefined) && emptyInput(input),
+          ...spawn.parentToolId ? { parent: spawn.parentToolId } : {}
         };
         memos.set(update.toolCallId, memo);
         out.push({
           type: "tool-start",
           toolId: update.toolCallId,
           name: memo.name,
-          input: update.rawInput ?? { locations: update.locations ?? [] },
+          input,
           ...memo.kind ? { kind: memo.kind } : {},
           title: memo.title,
-          ...spawnOf(update._meta)
+          ...spawn
         });
       }
+      if (update.rawInput !== undefined && update.content === undefined && update.status === undefined)
+        return out;
       const refined = { type: "tool-update", toolId: update.toolCallId };
       if (update.title && update.title !== memo.title) {
         memo.title = update.title;
         refined.title = update.title;
-        if (!update.name && memo.name !== update.title)
-          refined.name = memo.name = update.title;
       }
-      if (update.name && update.name !== memo.name)
+      if (update.name && update.name !== memo.name) {
         refined.name = memo.name = update.name;
+      }
       if (update.kind && update.kind !== memo.kind)
         refined.kind = memo.kind = update.kind;
-      if (update.rawInput !== undefined)
+      if (update.rawInput !== undefined) {
         refined.input = update.rawInput;
+        if (!emptyInput(update.rawInput))
+          memo.writing = false;
+      }
       if (Object.keys(refined).length > 2 && !memo.ended && out.length === 0)
         out.push(refined);
       if (update.content)
@@ -13827,6 +13927,7 @@ function steerOutcome(value) {
 
 // ../daemon/src/agent/acp/session.ts
 var DEFAULT_IDLE_MS = Number(process.env.TOYON_AGENT_IDLE_MS) || 5 * 60000;
+var OWN_SETTLE_MS = 1e4;
 function recorded(reply) {
   if (reply?.kind === "choice")
     return { choiceId: reply.choiceId };
@@ -13845,8 +13946,8 @@ class AcpSession {
   conn = null;
   connecting = null;
   live = null;
-  loading = false;
   reaper = null;
+  own = null;
   asking = 0;
   asks = new Map;
   log;
@@ -13874,13 +13975,38 @@ class AcpSession {
   async warmCommands() {
     if (this.commandList.length > 0 || this.stopped)
       return;
+    await this.warm();
+  }
+  async warm() {
+    if (this.stopped)
+      return;
     try {
-      await this.ensureLive();
+      await this.ensureLive("warm-up");
       this.maybeArmReaper();
     } catch (e) {
-      log.debug(this.d.worktreeId, `commands warm-up skipped: ${this.describe(e)}`);
+      log.debug(this.d.worktreeId, `agent warm-up skipped: ${this.describe(e)}`);
     }
   }
+  get runningAgent() {
+    return this.conn?.spec.id ?? null;
+  }
+  pgid_ = null;
+  get pgid() {
+    return this.pgid_;
+  }
+  noteProcess(link, up) {
+    if (link.pid === null)
+      return;
+    if (up)
+      this.pgid_ = link.pid;
+    else if (this.pgid_ === link.pid)
+      this.pgid_ = null;
+    this.d.onProcess?.(link.pid, up);
+  }
+  async restart() {
+    this.clearReaper();
+    await this.dropConn("restart");
+  }
   setCommands(next) {
     if (sameCommands(this.commandList, next))
       return;
@@ -13930,7 +14056,7 @@ class AcpSession {
       return log.warn(this.d.worktreeId, "send after close dropped");
     const { context, attachments } = opts;
     const item = { text, context, ...attachments?.length ? { attachments } : {} };
-    if (this.running && !this.interrupted && this.live?.conn.steering) {
+    if ((this.running || this.own) && !this.interrupted && this.live?.conn.steering) {
       return fireAndForget(this.d.worktreeId, this.steer(item), "agent steer");
     }
     this.enqueue(item);
@@ -13944,7 +14070,7 @@ class AcpSession {
   async steer(item) {
     item.recorded ??= await this.record(item);
     const live = this.live;
-    if (!live || !this.running || this.interrupted)
+    if (!live || !(this.running || this.own) || this.interrupted)
       return this.enqueue(item);
     this.steered.push(item);
     let outcome;
@@ -13982,8 +14108,14 @@ class AcpSession {
   }
   stop() {
     this.cancelAsks();
-    if (!this.running)
+    if (!this.running) {
+      if (this.own && this.live) {
+        const { conn, sessionId } = this.live;
+        fireAndForget(this.d.worktreeId, conn.ctx.notify(methods.agent.session.cancel, { sessionId }), "cancel");
+        this.endOwn("interrupted");
+      }
       return;
+    }
     this.interrupted = true;
     if (this.steered.length > 0) {
       this.queue.unshift(...this.steered);
@@ -14002,10 +14134,11 @@ class AcpSession {
     this.steered = [];
     this.queueChanged();
     this.stop();
-    await this.dropConn();
+    await this.dropConn("closing");
     await this.log.flush();
   }
   async drain() {
+    this.endOwn("end_turn");
     this.running = true;
     this.clearReaper();
     this.setStatus("working");
@@ -14043,7 +14176,7 @@ class AcpSession {
       } else {
         this.emit({ type: "agent-error", message: this.describe(e), ts: Date.now() });
         this.setStatus("error");
-        fireAndForget(this.d.worktreeId, this.dropConn(), "drop agent after error");
+        fireAndForget(this.d.worktreeId, this.dropConn("error"), "drop agent after error");
       }
     } finally {
       this.interrupted = false;
@@ -14058,7 +14191,7 @@ class AcpSession {
     this.asking++;
     this.clearReaper();
     try {
-      const conn = await this.ensureConn();
+      const conn = await this.ensureConn("an ask");
       return await askOnce(conn.ctx, {
         cwd: this.d.cwd,
         system,
@@ -14084,7 +14217,7 @@ class AcpSession {
     }
   }
   async authenticate(methodId, apiKey) {
-    const conn = await this.ensureConn();
+    const conn = await this.ensureConn("login");
     const method = conn.authMethods.find((m) => m.id === methodId);
     if (!method)
       throw new UserError(`${conn.spec.name} offers no login method "${methodId}"`);
@@ -14160,7 +14293,7 @@ class AcpSession {
   async runTurn(item) {
     item.recorded ??= await this.record(item);
     this.emit({ type: "turn-start", ts: Date.now() });
-    const live = await this.ensureLive();
+    const live = await this.ensureLive("a turn");
     await this.applyMode(live);
     await this.applyOption(live, "model");
     await this.applyOption(live, "thought_level");
@@ -14180,17 +14313,17 @@ class AcpSession {
   contextFor(item) {
     return ambientBlock([...item.context ?? [], this.d.preview?.()]);
   }
-  ensureConn() {
+  ensureConn(why) {
     if (this.conn)
       return Promise.resolve(this.conn);
     if (this.connecting)
       return this.connecting;
-    this.connecting = this.openConn().finally(() => {
+    this.connecting = this.openConn(why).finally(() => {
       this.connecting = null;
     });
     return this.connecting;
   }
-  async openConn() {
+  async openConn(why) {
     const spec = this.d.spec();
     const prepared = await (this.d.prepare ?? prepareLaunch)(this.d.cwd, spec);
     const { bounds } = prepared;
@@ -14202,13 +14335,17 @@ class AcpSession {
         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.cancelAsks();
+        this.endOwn("interrupted");
       }
     });
     try {
@@ -14227,7 +14364,7 @@ class AcpSession {
         spec,
         bounds,
         authMethods: init.authMethods ?? [],
-        loadSession: !!init.agentCapabilities?.loadSession,
+        resumeSession: !!init.agentCapabilities?.sessionCapabilities?.resume,
         closeSupported: !!init.agentCapabilities?.sessionCapabilities?.close,
         deleteSupported: !!init.agentCapabilities?.sessionCapabilities?.delete,
         acceptsImages: init.agentCapabilities?.promptCapabilities?.image === true,
@@ -14239,11 +14376,12 @@ class AcpSession {
       return this.conn;
     } catch (e) {
       fireAndForget(this.d.worktreeId, link.kill(), "kill agent after failed start");
+      this.noteProcess(link, false);
       throw e;
     }
   }
-  async ensureLive() {
-    const conn = await this.ensureConn();
+  async ensureLive(why) {
+    const conn = await this.ensureConn(why);
     if (this.live?.conn === conn)
       return this.live;
     const additionalDirectories = conn.bounds.gitDir ? [conn.bounds.gitDir] : [];
@@ -14251,10 +14389,9 @@ class AcpSession {
     let modes;
     let configOptions;
     let resumed = false;
-    if (sessionId && conn.loadSession) {
-      this.loading = true;
+    if (sessionId && conn.resumeSession) {
       try {
-        const r = await conn.ctx.request(methods.agent.session.load, {
+        const r = await conn.ctx.request(methods.agent.session.resume, {
           sessionId,
           cwd: this.d.cwd,
           mcpServers: [],
@@ -14267,8 +14404,6 @@ class AcpSession {
         if (isAuthRequired(e))
           throw e;
         log.warn(this.d.worktreeId, `could not resume agent session ${sessionId}; starting a new one`, e);
-      } finally {
-        this.loading = false;
       }
     }
     if (!resumed) {
@@ -14365,8 +14500,6 @@ class AcpSession {
         this.setCommands(mapped);
       return;
     }
-    if (this.loading)
-      return;
     const listener = side.get(params.sessionId);
     if (listener) {
       const u = params.update;
@@ -14384,7 +14517,10 @@ class AcpSession {
     }
     if (params.update.sessionUpdate === "config_option_update")
       this.absorb(live, params.update.configOptions);
-    for (const ev of mapUpdate(params.update, live.tools, this.d.worktreeId)) {
+    const events = mapUpdate(params.update, live.tools, this.d.worktreeId);
+    if (!this.running)
+      this.trackOwn(events);
+    for (const ev of events) {
       if (ev.type === "text-delta" || ev.type === "tool-start")
         this.steered = [];
       this.emit(ev.type === "session-info" ? { ...ev, sessionId: live.sessionId } : ev);
@@ -14417,17 +14553,18 @@ class AcpSession {
     }
     return pickOption(params.options, verdict);
   }
-  askPermission(params) {
+  async askPermission(params) {
     const plan = params.toolCall.kind === "switch_mode";
-    if (plan)
-      this.d.onPlan?.();
+    const detail = permissionDetail(params);
+    const planPath = plan ? await this.d.onPlan?.(detail) ?? null : null;
     const offered = plan ? params.options : params.options.filter((o) => o.kind !== "allow_always");
     const choices = offered.map((o) => ({ id: o.optionId, name: o.name, kind: o.kind }));
     return this.openAsk((id) => ({
       type: "agent-permission",
       id,
       title: params.toolCall.title ?? params.toolCall.name ?? "the agent needs a decision",
-      ...permissionDetail(params) ? { detail: permissionDetail(params) } : {},
+      ...detail ? { detail } : {},
+      ...planPath ? { plan: planPath } : {},
       choices,
       ...params.toolCall.toolCallId ? { toolId: params.toolCall.toolCallId } : {},
       ts: Date.now()
@@ -14438,10 +14575,17 @@ class AcpSession {
         return { outcome: { outcome: "cancelled" } };
       if (plan && (choice.kind === "allow_once" || choice.kind === "allow_always")) {
         this.d.setMode?.(modeAfterPlan(choice.name));
+        if (planPath)
+          fireAndForget(this.d.worktreeId, this.sayPlanEdited(detail, planPath), "edited plan");
       }
       return { outcome: { outcome: "selected", optionId: choice.id } };
     });
   }
+  async sayPlanEdited(proposed, path) {
+    if (!await this.d.planEdited?.(path, proposed))
+      return;
+    this.send(`I edited the plan before approving it. Build what is in ${path}, not the plan you proposed.`);
+  }
   onElicit(params, signal) {
     const live = this.live;
     if (!live || !("sessionId" in params) || params.sessionId !== live.sessionId) {
@@ -14499,21 +14643,56 @@ class AcpSession {
   syncStatus() {
     if (this.status === "error")
       return;
-    this.setStatus(this.asks.size > 0 ? "waiting" : this.running ? "working" : "idle");
+    this.setStatus(this.asks.size > 0 ? "waiting" : this.running || this.own ? "working" : "idle");
+  }
+  trackOwn(events) {
+    if (!this.own) {
+      const doing = events.some((e) => e.type === "text-delta" || e.type === "thinking-delta" || e.type === "tool-start");
+      if (!doing)
+        return;
+      this.own = { open: new Set, settle: null };
+      this.clearReaper();
+      this.emit({ type: "turn-start", ts: Date.now() });
+      this.syncStatus();
+    }
+    for (const e of events) {
+      if (e.type === "tool-start")
+        this.own.open.add(e.toolId);
+      else if (e.type === "tool-end")
+        this.own.open.delete(e.toolId);
+    }
+    if (this.own.settle)
+      clearTimeout(this.own.settle);
+    this.own.settle = null;
+    if (this.own.open.size > 0)
+      return;
+    const t = setTimeout(() => this.endOwn("end_turn"), this.d.ownSettleMs ?? OWN_SETTLE_MS);
+    t.unref?.();
+    this.own.settle = t;
+  }
+  endOwn(stopReason) {
+    if (!this.own)
+      return;
+    if (this.own.settle)
+      clearTimeout(this.own.settle);
+    this.own = null;
+    this.emit({ type: "turn-end", stopReason, ts: Date.now() });
+    this.syncStatus();
+    this.maybeArmReaper();
   }
   maybeArmReaper() {
-    if (!this.running && !this.asking && this.asks.size === 0 && this.conn && !this.stopped)
+    if (!this.running && !this.own && !this.asking && this.asks.size === 0 && this.conn && !this.stopped)
       this.armReaper();
   }
   armReaper() {
     this.clearReaper();
+    const idleMs = this.d.idleMs ?? DEFAULT_IDLE_MS;
     const t = setTimeout(() => {
       this.reaper = null;
-      if (this.running || this.asking || this.asks.size > 0 || !this.conn)
+      if (this.running || this.own || this.asking || this.asks.size > 0 || !this.conn)
         return;
-      log.debug(this.d.worktreeId, "agent idle; stopping its process");
-      fireAndForget(this.d.worktreeId, this.dropConn(), "reap agent");
-    }, this.d.idleMs ?? DEFAULT_IDLE_MS);
+      fireAndForget(this.d.worktreeId, this.dropConn(`idle for ${Math.round(idleMs / 60000)} min`), "reap agent");
+    }, idleMs);
     t.unref?.();
     this.reaper = t;
   }
@@ -14522,15 +14701,17 @@ class AcpSession {
       clearTimeout(this.reaper);
     this.reaper = null;
   }
-  async dropConn() {
+  async dropConn(why) {
     this.cancelAsks();
     const conn = this.conn;
     this.conn = null;
     this.live = null;
     if (!conn)
       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);
   }
 }
 function isAuthRequired(e) {
@@ -14593,6 +14774,217 @@ function sameCommands(a, b) {
   return a.length === b.length && a.every((c, i) => c.name === b[i]?.name && c.description === b[i]?.description && c.hint === b[i]?.hint);
 }
 
+// ../daemon/src/agent/planDoc.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
+var PLANS_DIR = join7(".toyon", "plans");
+var PLAN_NAME = /^(\d+)\.md$/;
+function isPlanPath(rel) {
+  return rel.startsWith(`${PLANS_DIR}/`) && PLAN_NAME.test(rel.slice(PLANS_DIR.length + 1));
+}
+function nextNumber(dir) {
+  if (!existsSync8(dir))
+    return 1;
+  let max = 0;
+  for (const name of readdirSync2(dir)) {
+    const n = Number(PLAN_NAME.exec(name)?.[1]);
+    if (n > max)
+      max = n;
+  }
+  return max + 1;
+}
+async function writePlanDoc(cwd, markdown) {
+  const dir = join7(cwd, PLANS_DIR);
+  const rel = join7(PLANS_DIR, `${nextNumber(dir)}.md`);
+  try {
+    mkdirSync5(dir, { recursive: true });
+    writeFileSync4(join7(cwd, rel), markdown.endsWith(`
+`) ? markdown : `${markdown}
+`);
+  } catch (e) {
+    log.warn(cwd, `could not write ${rel}; the plan stays on the card`, e);
+    return null;
+  }
+  await excludeFromGit(cwd, `${PLANS_DIR}/`);
+  return rel;
+}
+function planEdited(cwd, rel, proposed) {
+  const file = join7(cwd, rel);
+  if (!existsSync8(file))
+    return false;
+  try {
+    return readFileSync7(file, "utf8").trim() !== proposed.trim();
+  } catch (e) {
+    log.warn(cwd, `could not read ${rel}`, e);
+    return false;
+  }
+}
+
+// ../daemon/src/runtime/memory.ts
+var MAC_PRESSURE_CRITICAL = 4;
+var AVAILABLE_FLOOR = 0.15;
+var PAGING_FLOOR_BPS = 16 * 2 ** 20;
+var paging = [];
+var unsupportedLogged = false;
+async function memoryTight() {
+  const signal = process.platform === "darwin" ? await darwin() : process.platform === "linux" ? await linux() : null;
+  if (signal === null && !unsupportedLogged) {
+    unsupportedLogged = true;
+    log.warn("memory", `no memory pressure reading on ${process.platform}; nothing sleeps for memory`);
+  }
+  return signal;
+}
+async function darwin() {
+  const [r, v] = await Promise.all([
+    run("sysctl", ["-n", "kern.memorystatus_vm_pressure_level", "kern.memorystatus_level"], "/"),
+    run("vm_stat", [], "/")
+  ]);
+  if (!r.ok)
+    return null;
+  const [level, available] = r.out.split(/\s+/).map(Number);
+  if (level === undefined || available === undefined || Number.isNaN(level) || Number.isNaN(available))
+    return null;
+  const sample = v.ok ? parseVmStat(v.out, Date.now()) : null;
+  if (sample)
+    paging = [...paging, sample].slice(-3);
+  return darwinSignal(level, available, sustainedPaging(paging));
+}
+function parseVmStat(text, at) {
+  const pageSize = text.match(/page size of (\d+) bytes/);
+  const swapouts = text.match(/^Swapouts:\s+(\d+)/m);
+  if (!pageSize || !swapouts)
+    return null;
+  return { at, bytes: Number(swapouts[1]) * Number(pageSize[1]) };
+}
+function sustainedPaging(samples) {
+  if (samples.length < 3)
+    return null;
+  const rates = [];
+  for (let i = samples.length - 2;i < samples.length; i++) {
+    const prev = samples[i - 1];
+    const next = samples[i];
+    const seconds = (next.at - prev.at) / 1000;
+    const bytes = next.bytes - prev.bytes;
+    if (seconds <= 0 || bytes < 0)
+      return null;
+    rates.push(bytes / seconds);
+  }
+  return Math.min(...rates);
+}
+function darwinSignal(level, available, pagingBps = null) {
+  const pressure = level === 1 ? "normal" : level === 2 ? "warn" : level === MAC_PRESSURE_CRITICAL ? "critical" : `level ${level}`;
+  const swapping = pagingBps === null ? "" : `, swapping out ${Math.round(pagingBps / 2 ** 20)} MB/s`;
+  return {
+    tight: level === MAC_PRESSURE_CRITICAL || available < AVAILABLE_FLOOR * 100 || pagingBps !== null && pagingBps >= PAGING_FLOOR_BPS,
+    why: `memory pressure ${pressure} with ${available}% available${swapping}`
+  };
+}
+async function linux() {
+  let text;
+  try {
+    text = await Bun.file("/proc/meminfo").text();
+  } catch {
+    return null;
+  }
+  const field = (name) => {
+    const m = text.match(new RegExp(`^${name}:\\s+(\\d+)`, "m"));
+    return m ? Number(m[1]) : null;
+  };
+  const total = field("MemTotal");
+  const available = field("MemAvailable");
+  if (!total || available === null)
+    return null;
+  const percent = Math.round(available / total * 100);
+  return { tight: available / total < AVAILABLE_FLOOR, why: `${percent}% of memory available` };
+}
+async function sampleCosts(pgids) {
+  const costs = new Map;
+  if (pgids.length === 0)
+    return costs;
+  const wanted = new Set(pgids);
+  const r = await run("ps", ["-axo", "pgid=,rss="], "/");
+  if (!r.ok)
+    return costs;
+  for (const line of r.out.split(`
+`)) {
+    const [pgid, rss] = line.trim().split(/\s+/).map(Number);
+    if (pgid === undefined || rss === undefined || !wanted.has(pgid))
+      continue;
+    costs.set(pgid, (costs.get(pgid) ?? 0) + rss);
+  }
+  return costs;
+}
+async function bootId() {
+  if (process.platform === "darwin") {
+    const r = await run("sysctl", ["-n", "kern.boottime"], "/");
+    const m = r.ok ? r.out.match(/sec = (\d+)/) : null;
+    return m ? m[1] : null;
+  }
+  if (process.platform === "linux") {
+    try {
+      const m = (await Bun.file("/proc/stat").text()).match(/^btime (\d+)/m);
+      return m ? m[1] : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function psGroups(now = Date.now()) {
+  const r = await run("ps", ["-axo", "pid=,pgid=,ppid=,etime=,command="], "/");
+  if (!r.ok)
+    return [];
+  const rows = [];
+  for (const line of r.out.split(`
+`)) {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s*(.*)$/);
+    if (!m)
+      continue;
+    const elapsed = parseEtime(m[4]);
+    if (elapsed === null)
+      continue;
+    rows.push({
+      pid: Number(m[1]),
+      pgid: Number(m[2]),
+      ppid: Number(m[3]),
+      startedAt: now - elapsed * 1000,
+      command: m[5] ?? ""
+    });
+  }
+  return rows;
+}
+function parseEtime(text) {
+  const m = text.match(/^(?:(?:(\d+)-)?(\d+):)?(\d+):(\d+)$/);
+  if (!m)
+    return null;
+  const [, days, hours, minutes, seconds] = m;
+  return Number(days ?? 0) * 86400 + Number(hours ?? 0) * 3600 + Number(minutes) * 60 + Number(seconds);
+}
+
+// ../daemon/src/runtime/orphans.ts
+var GROUP_TTL_MS = 24 * 60 * 60000;
+var LEADER_SLACK_MS = 1e4;
+function orphansIn(ledger, rows, bootId, ledgerBootId, now) {
+  if (bootId === null || ledgerBootId === undefined || bootId !== ledgerBootId)
+    return [];
+  const out = [];
+  for (const entry of ledger) {
+    if (now - entry.startedAt > GROUP_TTL_MS)
+      continue;
+    const members = rows.filter((r) => r.pgid === entry.pgid);
+    if (members.length === 0)
+      continue;
+    const leader = members.find((r) => r.pid === entry.pgid);
+    if (leader && Math.abs(leader.startedAt - entry.startedAt) > LEADER_SLACK_MS)
+      continue;
+    out.push({ worktreeId: entry.worktreeId, pgid: entry.pgid, name: entry.name });
+  }
+  return out;
+}
+function strayAdapters(rows, agentsDir) {
+  return rows.filter((r) => r.pid === r.pgid && r.ppid === 1 && r.command.includes(agentsDir));
+}
+
 // ../daemon/src/runtime/ports.ts
 var allocated = new Set;
 var range = cloud.proxyPorts;
@@ -14705,7 +15097,7 @@ function expandEnv(env, vars) {
 
 // ../daemon/src/core/remote.ts
 import { createHmac, timingSafeEqual } from "crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
 function loadRemote(file, env = process.env) {
   if (env.TOYON_CLOUD === "1") {
     const host = (env.TOYON_PUBLIC_HOST ?? "").toLowerCase();
@@ -14718,9 +15110,9 @@ function loadRemote(file, env = process.env) {
       throw new Error(`TOYON_PREVIEWS: ${why}`);
     return { host, previews, front: "edge" };
   }
-  if (!existsSync8(file))
+  if (!existsSync9(file))
     return null;
-  const view = parseRemote(readFileSync7(file, "utf8"));
+  const view = parseRemote(readFileSync8(file, "utf8"));
   if (!view) {
     log.warn("remote", `${file} names no valid host or previews; remote access is off`);
     return null;
@@ -15381,7 +15773,7 @@ class WorktreeProcs {
   async killProc(mp) {
     await mp.pty?.kill();
   }
-  async sleep() {
+  async sleep(why) {
     if (this.asleep || this.stopped)
       return;
     this.asleep = true;
@@ -15389,6 +15781,7 @@ class WorktreeProcs {
     for (const mp of this.procs.values()) {
       mp.state.status = "asleep";
       mp.state.pid = undefined;
+      mp.state.detail = why;
       this.onProc({ ...mp.state });
       exits.push(this.killProc(mp));
     }
@@ -15403,13 +15796,16 @@ class WorktreeProcs {
       this.spawnProc(mp);
     }
   }
-  pgids() {
+  groups() {
     const out = [];
-    for (const mp of this.procs.values())
+    for (const [name, mp] of this.procs)
       if (mp.pty?.alive)
-        out.push(mp.pty.pid);
+        out.push({ name, pgid: mp.pty.pid });
     return out;
   }
+  pgids() {
+    return this.groups().map((g) => g.pgid);
+  }
   async stopAll() {
     this.stopped = true;
     const exits = [];
@@ -15478,11 +15874,12 @@ function terminalEnv(base, own, urls) {
 var DEFAULT_AGENT_ID = "claude";
 var PREVIEW_WAKE_MS = 8000;
 var PREVIEW_POLL_MS = 100;
-function defaultAgent(wt, d, preview) {
+function defaultAgent(wt, d, preview, onProcess) {
   const agent = new AcpSession({
     worktreeId: wt.id,
     cwd: wt.path,
     preview: () => previewContext(preview()),
+    onProcess,
     spec: () => {
       const w = d.state.requireWorktree(wt.id);
       if (!w.agent) {
@@ -15512,13 +15909,22 @@ function defaultAgent(wt, d, preview) {
       d.state.save();
       d.hub.emit("worktreesChanged");
     },
-    onPlan: () => {
+    onPlan: async (markdown) => {
       const w = d.state.worktree(wt.id);
-      if (!w || w.planned)
-        return;
-      w.planned = true;
-      d.state.save();
+      if (w && !w.planned) {
+        w.planned = true;
+        d.state.save();
+      }
+      const path = markdown.trim() ? await writePlanDoc(wt.path, markdown) : null;
+      const fresh = path ? d.state.worktree(wt.id) : undefined;
+      if (fresh && path && fresh.plan !== path) {
+        fresh.plan = path;
+        d.state.save();
+        d.hub.emit("worktreesChanged");
+      }
+      return path;
     },
+    planEdited: async (path, proposed) => planEdited(wt.path, path, proposed),
     option: (category) => d.state.requireWorktree(wt.id)[OPTION_FIELDS[category]],
     onOptionsLearned: (category, choices) => {
       const agentId = d.state.requireWorktree(wt.id).agent ?? "";
@@ -15568,8 +15974,10 @@ class RuntimeRegistry {
   holds = new Map;
   settingUp = new Set;
   starting = new Set;
+  stopping = new Map;
   constructor(deps) {
     this.deps = deps;
+    deps.hub.on("proc", (id) => this.recordGroups(id));
   }
   hold(id, tag) {
     let tags = this.holds.get(id);
@@ -15638,16 +16046,18 @@ class RuntimeRegistry {
     if (repo)
       await this.start(wt, repo);
   }
-  async sleep(id) {
+  async sleep(id, why) {
     const rt = this.runtimes.get(id);
     if (!rt?.procs || rt.procs.asleep)
       return;
+    log.info(id, `asleep: ${why}`);
     if (this.ports.ranged()) {
       rt.proxy?.stop();
       rt.proxy = null;
       this.returnLease(id);
     }
-    await rt.procs.sleep();
+    await rt.procs.sleep(why);
+    this.recordGroups(id);
     this.deps.hub.emit("worktreesChanged");
   }
   get ports() {
@@ -15704,11 +16114,15 @@ class RuntimeRegistry {
         args: ["-l"]
       };
       try {
-        term = (this.deps.makeTerminal ?? defaultTerminal)({ id }, opts, (data) => this.deps.hub.emit("termData", id, SHELL_STREAM, data), (code) => this.deps.hub.emit("termExit", id, SHELL_STREAM, code));
+        term = (this.deps.makeTerminal ?? defaultTerminal)({ id }, opts, (data) => this.deps.hub.emit("termData", id, SHELL_STREAM, data), (code) => {
+          this.deps.hub.emit("termExit", id, SHELL_STREAM, code);
+          this.recordGroups(id);
+        });
       } catch (e) {
         throw new UserError(`could not start a shell: ${e instanceof Error ? e.message : String(e)}`);
       }
       this.looseShells.set(id, term);
+      this.recordGroups(id);
     } else if (term.cols !== cols || term.rows !== rows) {
       term.resize(cols, rows);
     }
@@ -15723,6 +16137,7 @@ class RuntimeRegistry {
         continue;
       this.looseShells.delete(id);
       fireAndForget(id, Promise.resolve(term.kill()), "loose shell cleanup");
+      this.recordGroups(id);
     }
   }
   get(id) {
@@ -15744,7 +16159,7 @@ class RuntimeRegistry {
       return existing;
     const rt = {
       info: wt,
-      agent: (this.deps.makeAgent ?? defaultAgent)(wt, this.deps, () => this.previewStanding(wt.id)),
+      agent: (this.deps.makeAgent ?? defaultAgent)(wt, this.deps, () => this.previewStanding(wt.id), () => this.recordGroups(wt.id)),
       procs: null,
       proxy: null,
       previewName: undefined,
@@ -15760,6 +16175,8 @@ class RuntimeRegistry {
     const rt = this.ensureAgent(wt);
     if (rt.procs)
       return;
+    if (wt.kind === "main" && this.deps.mainLeads && !this.deps.mainLeads(wt.repoId))
+      return;
     const live = this.deps.state.requireWorktree(wt.id);
     const port = this.leasePort(live);
     if (port === null)
@@ -15810,12 +16227,11 @@ class RuntimeRegistry {
   leased = new Map;
   leasePort(wt) {
     let port = this.ports.lease(wt.proxyPort);
-    if (port === null && wt.kind !== "spare") {
+    if (port === null && (wt.kind !== "spare" || this.deps.shown?.(wt.id))) {
       const holders = [...this.leased.keys()].filter((id) => id !== wt.id && !this.starting.has(id) && !this.busy(id) && !this.deps.viewed?.(id));
       const victim = oldestViewed(holders, this.deps.state);
       if (victim) {
-        log.info(victim.id, `asleep: its preview port went to ${wt.title}`);
-        fireAndForget(victim.id, this.sleep(victim.id), "sleep for a preview port");
+        fireAndForget(victim.id, this.sleep(victim.id, `its preview port went to ${wt.title || wt.branch}`), "sleep for a preview port");
         port = this.ports.lease(wt.proxyPort);
       }
       if (port === null) {
@@ -15843,6 +16259,7 @@ class RuntimeRegistry {
     proxy?.stop();
     this.returnLease(id);
     await procs?.stopAll();
+    this.recordGroups(id);
   }
   async stop(id) {
     this.holds.delete(id);
@@ -15851,11 +16268,18 @@ class RuntimeRegistry {
     if (!rt)
       return;
     this.runtimes.delete(id);
+    this.stopping.set(id, rt);
     rt.proxy?.stop();
     this.returnLease(id);
     const login = rt.login;
     rt.login = null;
-    await Promise.all([rt.agent.close(), rt.procs?.stopAll(), rt.shell?.kill(), login?.pty.kill()]);
+    try {
+      await Promise.all([rt.agent.close(), rt.procs?.stopAll(), rt.shell?.kill(), login?.pty.kill()]);
+    } finally {
+      if (this.stopping.get(id) === rt)
+        this.stopping.delete(id);
+      this.recordGroups(id);
+    }
   }
   openTerminal(id, stream, cols, rows) {
     if (stream === LOGIN_STREAM)
@@ -15863,12 +16287,10 @@ class RuntimeRegistry {
     if (stream !== SHELL_STREAM)
       return this.openProcStream(id, stream, cols, rows);
     const wt = this.deps.state.requireWorktree(id);
-    if (wt.kind === "spare")
-      throw new UserError("no terminal for a spare worktree");
     const rt = this.ensureAgent(wt);
     let term = rt.shell;
     if (!term?.alive) {
-      const cwd = wt.linkPath ?? wt.path;
+      const cwd = wt.path;
       const opts = {
         cwd,
         env: { ...this.shellEnv(wt), PWD: cwd },
@@ -15878,11 +16300,15 @@ class RuntimeRegistry {
         args: ["-l"]
       };
       try {
-        term = (this.deps.makeTerminal ?? defaultTerminal)(wt, opts, (data) => this.deps.hub.emit("termData", wt.id, SHELL_STREAM, data), (code) => this.deps.hub.emit("termExit", wt.id, SHELL_STREAM, code));
+        term = (this.deps.makeTerminal ?? defaultTerminal)(wt, opts, (data) => this.deps.hub.emit("termData", wt.id, SHELL_STREAM, data), (code) => {
+          this.deps.hub.emit("termExit", wt.id, SHELL_STREAM, code);
+          this.recordGroups(wt.id);
+        });
       } catch (e) {
         throw new UserError(`could not start a shell: ${e instanceof Error ? e.message : String(e)}`);
       }
       rt.shell = term;
+      this.recordGroups(wt.id);
     } else if (term.cols !== cols || term.rows !== rows) {
       term.resize(cols, rows);
     }
@@ -15895,7 +16321,7 @@ class RuntimeRegistry {
     rt.login = null;
     if (prev)
       fireAndForget(id, Promise.resolve(prev.pty.kill()), "replace the agent login");
-    const cwd = wt.linkPath ?? wt.path;
+    const cwd = wt.path;
     let pty;
     try {
       pty = (this.deps.makeTerminal ?? defaultTerminal)(wt, {
@@ -15907,6 +16333,7 @@ class RuntimeRegistry {
         args: run.args
       }, (data) => this.deps.hub.emit("termData", id, LOGIN_STREAM, data), (code) => {
         this.deps.hub.emit("termExit", id, LOGIN_STREAM, code);
+        this.recordGroups(id);
         if (rt.login?.pty !== pty)
           return;
         if (code === 0) {
@@ -15919,6 +16346,7 @@ class RuntimeRegistry {
       throw new UserError(`could not start the login: ${e instanceof Error ? e.message : String(e)}`);
     }
     rt.login = { pty, run };
+    this.recordGroups(id);
     this.deps.hub.emit("worktreesChanged");
   }
   openLoginStream(id, cols, rows) {
@@ -15994,12 +16422,93 @@ class RuntimeRegistry {
     const url = `http://${host.includes(":") ? `[${host}]` : host}:${st.boundPort ?? st.port}`;
     return { status: st.status, url, ...st.detail ? { detail: st.detail } : {} };
   }
+  recordGroups(id) {
+    const rt = this.runtimes.get(id) ?? this.stopping.get(id);
+    const live = [];
+    if (rt) {
+      for (const g of rt.procs?.groups() ?? [])
+        live.push(g);
+      if (rt.agent.pgid !== null) {
+        const agentId = this.deps.state.worktree(id)?.agent ?? this.deps.state.defaultAgent ?? DEFAULT_AGENT_ID;
+        live.push({ name: `agent:${agentId}`, pgid: rt.agent.pgid });
+      }
+      if (rt.shell?.alive)
+        live.push({ name: "shell", pgid: rt.shell.pid });
+      if (rt.login?.pty.alive)
+        live.push({ name: "login", pgid: rt.login.pty.pid });
+    }
+    const loose = this.looseShells.get(id);
+    if (loose?.alive)
+      live.push({ name: "shell", pgid: loose.pid });
+    const before = new Map(this.deps.state.groups(id).map((g) => [g.pgid, g]));
+    const now = Date.now();
+    const next = live.map((g) => ({ ...g, startedAt: before.get(g.pgid)?.startedAt ?? now }));
+    this.deps.state.setGroups(id, next);
+  }
+  async reclaimOrphans() {
+    const machine = this.deps.machine ?? { bootId, psGroups };
+    const [boot, rows] = await Promise.all([machine.bootId(), machine.psGroups()]);
+    const state = this.deps.state;
+    const found = orphansIn(state.allGroups(), rows, boot, state.bootAt, Date.now());
+    const seen = new Set(found.map((o) => o.pgid));
+    for (const row of strayAdapters(rows, this.deps.paths.agentsDir)) {
+      if (seen.has(row.pgid))
+        continue;
+      seen.add(row.pgid);
+      found.push({ worktreeId: "daemon", pgid: row.pgid, name: "adapter" });
+    }
+    const reclaim = this.deps.reclaim ?? reclaimGroup;
+    await Promise.all(found.map(async (o) => {
+      await reclaim(o.pgid);
+      log.info(o.worktreeId, `reclaimed ${o.name} group ${o.pgid} left by the last daemon`);
+    }));
+    state.clearGroups();
+    state.setBootAt(boot);
+  }
   async shutdown() {
     this.pruneLooseShells(new Set);
     await Promise.all([...this.runtimes.keys()].map((id) => this.stop(id)));
   }
 }
 
+// ../daemon/src/worktrees/naming.ts
+import { randomBytes } from "crypto";
+import { existsSync as existsSync10 } from "fs";
+import { join as join8 } from "path";
+function shortId() {
+  return randomBytes(5).toString("hex");
+}
+function freeSlot(parent) {
+  for (;; ) {
+    const id = shortId();
+    const dir = `wt-${id.slice(0, 4)}`;
+    if (!existsSync10(join8(parent, dir)))
+      return { id, dir };
+  }
+}
+function titleFrom(prompt) {
+  const words = prompt.split(/\s+/).filter(Boolean).slice(0, 3).join(" ");
+  return sentenceCase(cleanTitle2(words) || "task");
+}
+function cleanTitle2(title) {
+  return title.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").slice(0, 40).replace(/^[\s:;,.!?]+|[\s:;,.!?]+$/g, "");
+}
+function branchSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+function sentenceCase(title) {
+  return title.charAt(0).toUpperCase() + title.slice(1);
+}
+var VARIANT_LENSES = [
+  "Take the most direct approach: the change most people would expect, in the smallest diff.",
+  "Lean toward how it looks and reads: polish what the task touches using only the design tokens, components and voice the project already has. Add no new colours, fonts or effects, and restyle nothing outside the task.",
+  "Lean toward behaviour: edge cases, empty and error states, and what can go wrong, over visual change."
+];
+function variantLens(index) {
+  const lens = VARIANT_LENSES[(index - 1) % VARIANT_LENSES.length];
+  return `(You are attempt ${index} of several parallel attempts at this task. Stay within the task and follow the project's existing styles, components, tokens and writing conventions; the attempts differ in emphasis, not in how much they change. ${lens})`;
+}
+
 // ../daemon/src/agent/recap.ts
 var REPLY_KEEP = 2000;
 var CLIP = 160;
@@ -16015,6 +16524,7 @@ function turnsSince(entries, seenAt) {
   let pending = [];
   let open = null;
   const writes = new Set;
+  const refusals = new Map;
   const start = (ts) => {
     const t = slice(pending, ts);
     pending = [];
@@ -16035,16 +16545,35 @@ function turnsSince(entries, seenAt) {
         open = start(e.ts);
         break;
       case "text-delta":
-        if (open)
+        if (open) {
           open.reply = (open.reply + e.text).slice(-REPLY_KEEP);
+          open.refused = undefined;
+        }
         break;
       case "tool-start":
         if (!open)
           break;
         if (!e.parentToolId)
           open.reply = "";
+        open.refused = undefined;
         countWrite(open, writes, e.toolId, e);
         break;
+      case "agent-permission":
+        refusals.set(e.id, new Set(e.choices.filter((c) => c.kind.startsWith("reject")).map((c) => c.id)));
+        if (open)
+          open.refused = undefined;
+        break;
+      case "agent-question":
+        if (open)
+          open.refused = undefined;
+        break;
+      case "agent-ask-end": {
+        const refusing = refusals.get(e.id);
+        refusals.delete(e.id);
+        if (open && e.outcome === "answered" && e.choiceId && refusing?.has(e.choiceId))
+          open.refused = true;
+        break;
+      }
       case "tool-update":
         if (open && e.kind)
           countWrite(open, writes, e.toolId, { name: e.name ?? "", kind: e.kind });
@@ -16101,7 +16630,8 @@ function factsOf(turns, end, ask) {
     ...end === "failed" && last?.error ? { error: last.error } : {},
     ...end === "failed" && last?.auth ? { auth: true } : {},
     ...end === "done" && cut ? { cut } : {},
-    ...end === "asking" && ask ? { ask } : {}
+    ...end === "asking" && ask ? { ask } : {},
+    ...end === "stopped" && last?.refused ? { planBack: true } : {}
   };
 }
 function firstAskOf(entries) {
@@ -16110,59 +16640,6 @@ function firstAskOf(entries) {
       return e.text;
   return;
 }
-var RECAP_SYSTEM = "You write one-line status recaps for a developer coming back to a coding task. Reply with only the recap.";
-var RECAP_ASK = "The user stepped away and is coming back. Recap in one sentence, under 20 words, no markdown. Say what the task is, then what just happened or what to do next. Skip root-cause narrative, fix internals and secondary to-dos.";
-var RECAP_TURNS = 6;
-var RECAP_CHARS = 4000;
-function recapPrompt(i) {
-  const head = [RECAP_ASK, "", `Task: ${clip(i.title, 200)}`];
-  if (i.firstAsk)
-    head.push(`First request: ${clip(i.firstAsk, 300)}`);
-  const now = `Now: ${standing(i.end, i.facts)}`;
-  let blocks = i.turns.slice(-RECAP_TURNS).map(turnBlock);
-  const size = () => [...head, "", ...blocks, "", now].join(`
-
-`).length;
-  while (blocks.length > 1 && size() > RECAP_CHARS)
-    blocks = blocks.slice(1);
-  return [head.join(`
-`), blocks.join(`
-
-`), now].join(`
-
-`);
-}
-function turnBlock(t) {
-  const facts = [t.edits ? plural(t.edits, "edit") : "", t.toolErrors ? plural(t.toolErrors, "failed tool") : ""].filter(Boolean).join(", ");
-  const lines = [];
-  if (t.asks.length)
-    lines.push(`You asked: ${clip(t.asks.join(" / "), 400)}`);
-  if (t.reply.trim())
-    lines.push(`Agent ended with: ${tail(t.reply, 800)}`);
-  if (facts)
-    lines.push(`Facts: ${facts}`);
-  return lines.join(`
-`);
-}
-function standing(end, f) {
-  switch (end) {
-    case "asking":
-      return f.ask ? `waiting for the user's answer to "${f.ask}"` : "waiting for the user";
-    case "failed":
-      return f.error ? `failed: ${f.error}` : "failed";
-    case "stopped":
-      return "stopped before it finished";
-    case "done":
-      return f.cut ? `finished early (${f.cut})` : "finished";
-  }
-}
-function plural(n, word) {
-  return `${n} ${word}${n === 1 ? "" : "s"}`;
-}
-function tail(text, max) {
-  const line = text.replace(/\s+/g, " ").trim();
-  return line.length > max ? `\u2026${line.slice(-(max - 1))}` : line;
-}
 var RECAP_MAX = 160;
 function parseRecap(text) {
   if (!text)
@@ -16179,15 +16656,17 @@ function parseRecap(text) {
 }
 
 // ../daemon/src/agent/landing.ts
-var LAND_SYSTEM = "You judge whether a coding task is finished and write its commit message. Reply in exactly the format asked, nothing else.";
+var LAND_SYSTEM = "You judge whether a coding task is finished, recap where it stands, and write its commit message. Reply in exactly the format asked, nothing else.";
 var LAND_ASK = [
   "A coding agent just stopped in a git worktree. Decide whether the work is finished and ready to merge, or still in progress: a question the agent is waiting on, a step it said it would do next, or a part of the request it did not get to.",
   "The agent never commits: every change is left uncommitted for the user, and the agent saying so is normal, not a sign the work is unfinished.",
   "Reply with exactly this shape and nothing else:",
-  "Line 1: READY, or NOT READY: <reason under 12 words>",
+  "Line 1: READY, or NOT READY: <what is still left to do, under 8 words, about the change itself and not the conversation>",
   "Line 2: blank",
-  "Line 3: a commit subject under 60 characters, lowercase, imperative, in the style of the recent subjects when given",
+  "Line 3: Recap: one sentence under 20 words for the user coming back to this task, saying what the task is and then what just happened or what to do next. Skip root-cause narrative, fix internals and secondary to-dos.",
   "Line 4: blank",
+  "Line 5: a commit subject under 60 characters, lowercase, imperative, in the style of the recent subjects when given",
+  "Line 6: blank",
   "Then: a short body, 1 to 4 plain sentences on what changed and why. No markdown, no bullets, no dashes as punctuation."
 ].join(`
 `);
@@ -16203,7 +16682,7 @@ ${i.recentSubjects.map((s) => `  ${s}`).join(`
 `)}`);
   const diff = `Diff summary:
 ${i.diffStat.trim() || "(none)"}`;
-  let blocks = i.turns.slice(-LAND_TURNS).map(turnBlock2);
+  let blocks = i.turns.slice(-LAND_TURNS).map(turnBlock);
   const size = () => [...head, "", ...blocks, "", diff].join(`
 
 `).length;
@@ -16216,13 +16695,36 @@ ${i.diffStat.trim() || "(none)"}`;
 
 `);
 }
-function turnBlock2(t) {
+function turnBlock(t) {
   const lines = [];
   if (t.asks.length)
     lines.push(`User asked: ${clip(t.asks.join(" / "), 400)}`);
   if (t.reply.trim())
     lines.push(`Agent ended with: ${clip(t.reply, 1000)}`);
   return lines.join(`
+`);
+}
+var ANSWER_SYSTEM = "You recap where a coding task stands in one sentence. Reply with the sentence only.";
+var ANSWER_ASK = [
+  "A coding agent just replied in a git worktree without changing any files: it answered a question, reviewed something, or explained what it found.",
+  "Write one sentence under 20 words for the user coming back to this task, saying what was asked and what the agent answered or recommended. Skip narrative and secondary points. No markdown, no dashes as punctuation."
+].join(`
+`);
+function answerPrompt(i) {
+  const head = [ANSWER_ASK, "", `Task: ${clip(i.title, 200)}`];
+  if (i.firstAsk)
+    head.push(`First request: ${clip(i.firstAsk, 300)}`);
+  let blocks = i.turns.slice(-LAND_TURNS).map(turnBlock);
+  const size = () => [...head, "", ...blocks].join(`
+
+`).length;
+  while (blocks.length > 1 && size() > LAND_CHARS)
+    blocks = blocks.slice(1);
+  return [head.join(`
+`), blocks.join(`
+
+`)].join(`
+
 `);
 }
 var SUBJECT_MAX = 72;
@@ -16239,13 +16741,17 @@ function parseLanding(text) {
   const rest = lines.slice(lines.indexOf(lines.find((l) => l.trim() === first) ?? "") + 1);
   const paragraphs = rest.join(`
 `).split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
-  const subject = paragraphs[0]?.replace(/\s+/g, " ").replace(/^(subject|title)\s*:\s*/i, "").replace(/[.]+$/, "").slice(0, SUBJECT_MAX).trim();
-  const body = paragraphs.slice(1).join(`
+  const hasRecap = /^recap\s*:/i.test(paragraphs[0] ?? "") || paragraphs.length >= 3;
+  const recap = hasRecap ? parseRecap(paragraphs[0] ?? null) : null;
+  const message = hasRecap ? paragraphs.slice(1) : paragraphs;
+  const subject = message[0]?.replace(/\s+/g, " ").replace(/^(subject|title)\s*:\s*/i, "").replace(/[.]+$/, "").slice(0, SUBJECT_MAX).trim();
+  const body = message.slice(1).join(`
 
 `).replace(/^(body)\s*:\s*/i, "").trim();
   return {
     ready: verdict === "ready",
     ...why ? { why: clip(why, 120) } : {},
+    ...recap ? { recap } : {},
     ...subject && subject.split(" ").length >= 2 ? { subject } : {},
     ...body ? { body: body.slice(0, 1500) } : {}
   };
@@ -16299,7 +16805,7 @@ async function askFreshAgent(agents, agentId, cwd, system, prompt, opts = {}) {
 
 // ../daemon/src/agent/tasks.ts
 var NAME_SYSTEM = "You are a naming assistant. Reply with only the requested name.";
-var namePrompt = (task) => `Name this coding task the way a teammate would say it out loud: 1 or 2 lowercase kebab-case words, 16 characters at most (like "sticky-header", "dark-mode", "price-badge"). Leave out words every task in the project would share, like the product or the app. Reply with ONLY the name, nothing else.
+var namePrompt = (task) => `Name this coding task the way a teammate would say it out loud: 1 or 2 plain lowercase words, 16 characters at most (like "sticky header", "dark mode", "price badge"). Leave out words every task in the project would share, like the product or the app. Reply with ONLY the name, nothing else.
 
 Task: ${task.slice(0, 500)}`;
 function taskText(text, attachments = []) {
@@ -16321,13 +16827,13 @@ function parseName(text) {
     return null;
   const line = text.trim().split(`
 `).at(-1) ?? "";
-  const name = line.toLowerCase().replace(/[`"'.]/g, "").replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
-  const words = name.split("-").filter(Boolean);
+  const name = line.toLowerCase().replace(/[`"'.]/g, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+  const words = name.split(" ").filter(Boolean);
   if (words.length < 1 || words.length > 3 || name.length < 3 || name.length > 20)
     return null;
   if (/error|fail|sorry|cannot|unable|unauthori|forbidden|denied|\b[45]\d\d\b/.test(name))
     return null;
-  return name;
+  return sentenceCase(name);
 }
 var PLAN_SYSTEM = "You are a task-planning assistant. Reply with only the requested JSON.";
 var planPrompt = (request) => [
@@ -16357,15 +16863,6 @@ function parsePlan(text) {
 function makeNamer(runtime) {
   return async (task, wt) => parseName(await runtime.ensureAgent(wt).agent.ask(NAME_SYSTEM, namePrompt(task), { quick: "prefer" }));
 }
-function makeRecapper(runtime, agents, state) {
-  return async (wt, prompt) => {
-    const spec = agents.get(wt.agent ?? state.defaultAgent ?? DEFAULT_AGENT_ID);
-    if (!spec || lacksQuickModel(spec, state))
-      return null;
-    const agent = runtime.agentFor(wt.id);
-    return agent ? parseRecap(await agent.ask(RECAP_SYSTEM, prompt, { quick: "require" })) : null;
-  };
-}
 function lacksQuickModel(spec, state) {
   const quick = spec.quickModel;
   if (!quick)
@@ -16375,43 +16872,51 @@ function lacksQuickModel(spec, state) {
   const offered = state.cachedOptions(spec.id, "model");
   return offered.length > 0 && !offered.some((m) => m.id === quick);
 }
-function makeLander(runtime, agents, state) {
-  return async (wt, prompt) => {
+function makeQuickAsker(runtime, agents, state) {
+  return async (wt, system, prompt) => {
     const spec = agents.get(wt.agent ?? state.defaultAgent ?? DEFAULT_AGENT_ID);
     if (!spec || lacksQuickModel(spec, state))
       return null;
     const agent = runtime.agentFor(wt.id);
-    return agent ? parseLanding(await agent.ask(LAND_SYSTEM, prompt, { quick: "require" })) : null;
+    return agent ? agent.ask(system, prompt, { quick: "require" }) : null;
   };
 }
+function makeLander(...deps) {
+  const ask = makeQuickAsker(...deps);
+  return async (wt, prompt) => parseLanding(await ask(wt, LAND_SYSTEM, prompt));
+}
+function makeAnswerRecapper(...deps) {
+  const ask = makeQuickAsker(...deps);
+  return async (wt, prompt) => parseRecap(await ask(wt, ANSWER_SYSTEM, prompt));
+}
 function makePlanner(agents) {
   return async (request, cwd, agentId) => parsePlan(await askFreshAgent(agents, agentId, cwd, PLAN_SYSTEM, planPrompt(request), { quick: "prefer" }));
 }
 
 // ../daemon/src/core/assets.ts
-import { existsSync as existsSync9, readdirSync as readdirSync2, rmSync, statSync as statSync2 } from "fs";
-import { join as join7, resolve as resolve5 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3, rmSync, statSync as statSync2 } from "fs";
+import { join as join9, resolve as resolve5 } from "path";
 function locateAssets(here, env = process.env) {
-  const packaged = existsSync9(join7(here, "shell", "index.html"));
+  const packaged = existsSync11(join9(here, "shell", "index.html"));
   return {
-    shellDist: env.TOYON_SHELL_DIST ?? (packaged ? join7(here, "shell") : join7(here, "../../shell/dist")),
-    bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join7(here, "bridge.js") : join7(here, "../../bridge/dist/bridge.js")),
+    shellDist: env.TOYON_SHELL_DIST ?? (packaged ? join9(here, "shell") : join9(here, "../../shell/dist")),
+    bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join9(here, "bridge.js") : join9(here, "../../bridge/dist/bridge.js")),
     sourceRoot: packaged ? null : resolve5(here, "../../.."),
-    packageJson: packaged ? join7(here, "..", "package.json") : null
+    packageJson: packaged ? join9(here, "..", "package.json") : null
   };
 }
 var KEEP_MS = 3 * 24 * 60 * 60 * 1000;
 function pruneAssets(shellDist) {
-  const dir = join7(shellDist, "assets");
+  const dir = join9(shellDist, "assets");
   let names;
   try {
-    names = readdirSync2(dir);
+    names = readdirSync3(dir);
   } catch {
     return 0;
   }
   const found = [];
   for (const name of names) {
-    const path = join7(dir, name);
+    const path = join9(dir, name);
     try {
       found.push({ path, mtime: statSync2(path).mtimeMs });
     } catch {}
@@ -16432,7 +16937,7 @@ function pruneAssets(shellDist) {
 }
 
 // ../daemon/src/core/dialog.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { homedir as homedir4 } from "os";
 var PROMPTS = {
   location: "Choose where the new project goes",
@@ -16450,7 +16955,7 @@ function folderDialog() {
   let cancelled = false;
   const ask = async (start, purpose) => {
     const typed = start === "~" || start.startsWith("~/") ? `${homedir4()}${start.slice(1)}` : start;
-    const from = typed.startsWith("/") && existsSync10(typed) ? typed : homedir4();
+    const from = typed.startsWith("/") && existsSync12(typed) ? typed : homedir4();
     cancelled = false;
     const p = Bun.spawn(["osascript", ...SCRIPT.flatMap((line) => ["-e", line]), PROMPTS[purpose], from], {
       stdout: "pipe",
@@ -16554,12 +17059,12 @@ class Restarter {
     d.hub.on("agentStatus", settle);
     d.hub.on("worktreesChanged", settle);
   }
-  request() {
+  request(opts = {}) {
     const refused = this.d.refusal();
     if (refused)
       return refused;
     this.asked = true;
-    this.attempt();
+    this.attempt(opts.now);
     return null;
   }
   waitingOn() {
@@ -16568,13 +17073,18 @@ class Restarter {
     return this.gone ? [] : this.working();
   }
   working() {
-    return this.d.state.worktrees.filter((w) => this.d.runtime.agentFor(w.id)?.status === "working").map((w) => w.title);
+    return this.titled("working");
+  }
+  asking() {
+    return this.titled("waiting");
   }
-  attempt() {
+  titled(status) {
+    return this.d.state.worktrees.filter((w) => this.d.runtime.agentFor(w.id)?.status === status).map((w) => w.title);
+  }
+  attempt(now = false) {
     if (this.gone)
       return;
-    const names = this.working();
-    if (names.length === 0)
+    if (now || this.working().length === 0)
       this.gone = true;
     const key = JSON.stringify(this.waitingOn());
     if (key !== this.announced) {
@@ -16666,18 +17176,19 @@ class SelfWatch {
 }
 
 // ../daemon/src/core/state.ts
-import { randomBytes } from "crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
+import { randomBytes as randomBytes2 } from "crypto";
+import { existsSync as existsSync13, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "fs";
+var GROUPS_SAVE_MS = 250;
 var SEEN_WORKTREES = 50;
 var empty = { repos: [], worktrees: [], sessions: {} };
 function loadState(paths) {
   ensureDirs(paths);
   const STATE_FILE = paths.stateFile;
-  if (!existsSync11(STATE_FILE))
+  if (!existsSync13(STATE_FILE))
     return structuredClone(empty);
   let raw;
   try {
-    raw = readFileSync8(STATE_FILE, "utf8");
+    raw = readFileSync9(STATE_FILE, "utf8");
   } catch (e) {
     log.error("state", `cannot read ${STATE_FILE}; starting empty`, e);
     return structuredClone(empty);
@@ -16688,7 +17199,7 @@ function loadState(paths) {
   } catch (e) {
     const backup = `${STATE_FILE}.corrupt-${Date.now()}`;
     try {
-      writeFileSync4(backup, raw);
+      writeFileSync5(backup, raw);
     } catch (be) {
       log.warn("state", "could not write the corrupt-state backup", be);
     }
@@ -16703,6 +17214,10 @@ function loadState(paths) {
     if (!ids.has(id) && !id.startsWith("disc-"))
       delete state.seen?.[id];
   }
+  for (const id of Object.keys(state.groups ?? {})) {
+    if (!ids.has(id) && !id.startsWith("disc-"))
+      delete state.groups?.[id];
+  }
   if (state.modelCache) {
     state.optionCache ??= {};
     for (const [agentId, models] of Object.entries(state.modelCache)) {
@@ -16715,22 +17230,23 @@ function loadState(paths) {
 }
 function saveState(paths, state) {
   const tmp = `${paths.stateFile}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(state, null, 2));
+  writeFileSync5(tmp, JSON.stringify(state, null, 2));
   renameSync2(tmp, paths.stateFile);
 }
 function loadOrCreateToken(paths) {
   ensureDirs(paths);
   const TOKEN_FILE = paths.tokenFile;
-  if (existsSync11(TOKEN_FILE))
-    return readFileSync8(TOKEN_FILE, "utf8").trim();
-  const token = randomBytes(32).toString("hex");
-  writeFileSync4(TOKEN_FILE, token, { mode: 384 });
+  if (existsSync13(TOKEN_FILE))
+    return readFileSync9(TOKEN_FILE, "utf8").trim();
+  const token = randomBytes2(32).toString("hex");
+  writeFileSync5(TOKEN_FILE, token, { mode: 384 });
   return token;
 }
 
 class StateStore {
   paths;
   state;
+  groupsTimer = null;
   constructor(paths, state) {
     this.paths = paths;
     this.state = state ?? loadState(paths);
@@ -16813,6 +17329,55 @@ class StateStore {
     delete this.state.sessions[id];
     if (this.state.seen)
       delete this.state.seen[id];
+    if (this.state.groups)
+      delete this.state.groups[id];
+    this.save();
+  }
+  groups(worktreeId) {
+    return this.state.groups?.[worktreeId] ?? [];
+  }
+  setGroups(worktreeId, list) {
+    this.state.groups ??= {};
+    if (list.length === 0)
+      delete this.state.groups[worktreeId];
+    else
+      this.state.groups[worktreeId] = list;
+    if (this.groupsTimer)
+      return;
+    const t = setTimeout(() => {
+      try {
+        this.save();
+      } catch (e) {
+        log.warn("state", "could not write the process group ledger", e);
+      }
+    }, GROUPS_SAVE_MS);
+    t.unref?.();
+    this.groupsTimer = t;
+  }
+  flushGroups() {
+    if (this.groupsTimer)
+      this.save();
+  }
+  allGroups() {
+    const out = [];
+    for (const [worktreeId, list] of Object.entries(this.state.groups ?? {})) {
+      for (const g of list)
+        out.push({ ...g, worktreeId });
+    }
+    return out;
+  }
+  clearGroups() {
+    delete this.state.groups;
+    this.save();
+  }
+  get bootAt() {
+    return this.state.bootAt;
+  }
+  setBootAt(id) {
+    if (id === null)
+      delete this.state.bootAt;
+    else
+      this.state.bootAt = id;
     this.save();
   }
   session(worktreeId) {
@@ -16873,12 +17438,15 @@ class StateStore {
     this.save();
   }
   save() {
+    if (this.groupsTimer)
+      clearTimeout(this.groupsTimer);
+    this.groupsTimer = null;
     saveState(this.paths, this.state);
   }
 }
 
 // ../daemon/src/design/service.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 
 // ../daemon/src/design/scan.ts
 var COLOR = /^(#|rgba?\(|hsla?\(|oklch\(|oklab\(|lab\(|lch\(|color\(|color-mix\(|light-dark\()/i;
@@ -17328,7 +17896,7 @@ class DesignService {
 async function readAll(root, paths) {
   const out = [];
   for (const path of paths) {
-    const file = Bun.file(join8(root, path));
+    const file = Bun.file(join10(root, path));
     if (file.size === 0 || file.size > MAX_FILE_BYTES)
       continue;
     try {
@@ -17443,14 +18011,14 @@ function typicalUse(classes) {
 var normal = (s) => s.replace(/[-_]/g, "").toLowerCase();
 async function loadProjectTypescript(root) {
   try {
-    return await import(join8(root, "node_modules", "typescript", "lib", "typescript.js"));
+    return await import(join10(root, "node_modules", "typescript", "lib", "typescript.js"));
   } catch {
     return null;
   }
 }
 
 // ../daemon/src/drafts/store.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "fs";
 var SAVE_DELAY_MS = 1000;
 
 class DraftStore {
@@ -17459,10 +18027,10 @@ class DraftStore {
   saveTimer = null;
   constructor(d) {
     this.d = d;
-    if (!existsSync12(d.file))
+    if (!existsSync14(d.file))
       return;
     try {
-      const raw = JSON.parse(readFileSync9(d.file, "utf8"));
+      const raw = JSON.parse(readFileSync10(d.file, "utf8"));
       if (!raw || typeof raw !== "object")
         return;
       for (const [id, text] of Object.entries(raw)) {
@@ -17479,6 +18047,9 @@ class DraftStore {
   has(boxId) {
     return !!this.drafts[boxId]?.trim();
   }
+  text(boxId) {
+    return this.drafts[boxId] ?? "";
+  }
   set(boxId, text, clientId) {
     if ((this.drafts[boxId] ?? "") === text)
       return;
@@ -17522,7 +18093,7 @@ class DraftStore {
   write() {
     const tmp = `${this.d.file}.tmp`;
     try {
-      writeFileSync5(tmp, JSON.stringify(this.drafts));
+      writeFileSync6(tmp, JSON.stringify(this.drafts));
       renameSync3(tmp, this.d.file);
     } catch (e) {
       log.error("drafts", "could not write the drafts", e);
@@ -17546,16 +18117,20 @@ class ExecService {
   run(worktreeId, command) {
     fireAndForget(worktreeId, this.exec(worktreeId, command), `exec ${command}`);
   }
-  exec(worktreeId, command, name = SHELL_TOOL) {
+  exec(worktreeId, command, name = SHELL_TOOL, opts = {}) {
     const wt = this.deps.state.requireWorktree(worktreeId);
     if (wt.kind === "spare")
       throw new UserError("no shell for a spare worktree");
+    if (wt.kind === "main")
+      throw new UserError("nothing runs on main: the plus starts a worktree for it");
     const agent = this.deps.runtime.agentFor(worktreeId);
     if (!agent)
       throw new UserError("worktree still starting; try again in a moment");
     const toolId = `${name}-${Date.now().toString(36)}-${++this.n}`;
-    agent.note({ type: "tool-start", toolId, name, input: { command }, kind: "execute" });
-    const cwd = wt.linkPath ?? wt.path;
+    const start = { type: "tool-start", toolId, name, input: { command }, kind: "execute" };
+    if (!opts.quiet)
+      agent.note(start);
+    const cwd = wt.path;
     const env = { ...this.deps.runtime.shellEnv(wt), PWD: cwd, TERM: "dumb", NO_COLOR: "1" };
     let proc;
     try {
@@ -17568,13 +18143,28 @@ class ExecService {
       });
     } catch (e) {
       const reason = e instanceof Error ? e.message : String(e);
+      if (opts.quiet)
+        agent.note(start);
       agent.note({ type: "tool-end", toolId, output: `could not run: ${reason}`, isError: true });
       return Promise.resolve({ exit: reason, text: "" });
     }
     const timer = setTimeout(() => this.kill(worktreeId, toolId), TIMEOUT_MS);
     this.track(worktreeId, toolId, { proc, timer });
     this.deps.runtime.hold(worktreeId, `exec:${toolId}`);
-    return this.collect(worktreeId, toolId, proc, agent);
+    return this.collect(worktreeId, toolId, proc, agent, opts.quiet ? start : undefined);
+  }
+  record(worktreeId, command, text, exit) {
+    const wt = this.deps.state.requireWorktree(worktreeId);
+    if (wt.kind === "spare")
+      throw new UserError("no shell for a spare worktree");
+    const agent = this.deps.runtime.agentFor(worktreeId);
+    if (!agent)
+      throw new UserError("worktree still starting; try again in a moment");
+    const toolId = `${SHELL_TOOL}-${Date.now().toString(36)}-${++this.n}`;
+    agent.note({ type: "tool-start", toolId, name: SHELL_TOOL, input: { command }, kind: "execute" });
+    const truncated = text.length > OUTPUT_CAP;
+    const shown = truncated ? text.slice(0, OUTPUT_CAP) : text;
+    agent.note({ type: "tool-end", toolId, output: formatOutput(shown, exit, truncated), isError: exit !== 0 });
   }
   stop(worktreeId) {
     for (const toolId of this.running.get(worktreeId)?.keys() ?? [])
@@ -17606,7 +18196,7 @@ class ExecService {
         r.proc.kill("SIGKILL");
     }, KILL_GRACE_MS2);
   }
-  async collect(worktreeId, toolId, proc, agent) {
+  async collect(worktreeId, toolId, proc, agent, heldStart) {
     let text = "";
     let truncated = false;
     const drain = async (stream) => {
@@ -17641,6 +18231,10 @@ class ExecService {
         clearTimeout(r.timer);
       this.deps.runtime.release(worktreeId, `exec:${toolId}`);
     }
+    if (heldStart && exit === 0)
+      return { exit, text };
+    if (heldStart)
+      agent.note(heldStart);
     agent.note({ type: "tool-end", toolId, output: formatOutput(text, exit, truncated), isError: exit !== 0 });
     return { exit, text };
   }
@@ -17687,7 +18281,7 @@ function withRepoLock(repoPath, fn) {
 var fileLockKey = (absPath) => `file:${absPath}`;
 
 // ../daemon/src/git/status.ts
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 async function treeFingerprint(worktreePath) {
   const [head, diff, untracked] = await Promise.all([
     git(worktreePath, "rev-parse", "HEAD"),
@@ -17697,7 +18291,7 @@ async function treeFingerprint(worktreePath) {
   const others = await Promise.all(untracked.out.split(`
 `).filter(Boolean).map(async (p) => {
     try {
-      const f = Bun.file(join9(worktreePath, p));
+      const f = Bun.file(join11(worktreePath, p));
       const body = f.size > 2000000 ? String(f.size) : Bun.hash(await f.arrayBuffer()).toString(36);
       return `${p}:${body}`;
     } catch {
@@ -17748,7 +18342,7 @@ async function numstat(worktreePath, ...range) {
 }
 async function untrackedLines(worktreePath, file) {
   try {
-    const f = Bun.file(join9(worktreePath, file));
+    const f = Bun.file(join11(worktreePath, file));
     if (f.size > 2000000)
       return {};
     const buf = new Uint8Array(await f.arrayBuffer());
@@ -17767,14 +18361,16 @@ async function untrackedLines(worktreePath, file) {
     return {};
   }
 }
+var MAX_UNTRACKED_COUNTED = 500;
 async function statusFilesWithCounts(worktreePath) {
   const files = await statusFiles(worktreePath);
   if (files.length === 0)
     return files;
   const counts = files.some((f) => f.xy !== "??") ? await numstat(worktreePath, "HEAD") : new Map;
+  const countUntracked = files.filter((f) => f.xy === "??").length <= MAX_UNTRACKED_COUNTED;
   return Promise.all(files.map(async (f) => ({
     ...f,
-    ...f.xy === "??" ? await untrackedLines(worktreePath, f.path) : counts.get(f.path) ?? {}
+    ...f.xy === "??" ? countUntracked ? await untrackedLines(worktreePath, f.path) : {} : counts.get(f.path) ?? {}
   })));
 }
 async function committedFiles(worktreePath, defaultBr) {
@@ -17824,6 +18420,10 @@ async function behindUpstream(worktreePath) {
   const r = await git(worktreePath, "rev-list", "--count", "HEAD..@{upstream}");
   return r.ok ? Number(r.out) || 0 : null;
 }
+async function aheadUpstream(worktreePath) {
+  const r = await git(worktreePath, "rev-list", "--count", "@{upstream}..HEAD");
+  return r.ok ? Number(r.out) || 0 : null;
+}
 async function aheadBehind(worktreePath, defaultBr) {
   const [a, b] = await Promise.all([
     git(worktreePath, "rev-list", "--count", `${defaultBr}..HEAD`),
@@ -18042,7 +18642,7 @@ function rankElementSources(el, rows) {
 // ../daemon/src/files/listing.ts
 var SUBMODULE_MODE = "160000";
 var entries = (out) => out.split("\x00").filter(Boolean);
-function parseListing(staged, untracked, deleted) {
+function parseListing(staged, untracked, deleted, ignored = "") {
   const gone = new Set(entries(deleted));
   const paths = new Set;
   const submodules = new Set;
@@ -18060,7 +18660,18 @@ function parseListing(staged, untracked, deleted) {
   }
   for (const path of entries(untracked))
     paths.add(path);
-  return { paths: [...paths], submodules: [...submodules] };
+  return { paths: [...paths], submodules: [...submodules], ignored: collapse(entries(ignored)) };
+}
+function collapse(list) {
+  const out = [];
+  let under = null;
+  for (const p of [...list].sort()) {
+    if (under !== null && p.startsWith(under))
+      continue;
+    under = p.endsWith("/") ? p : null;
+    out.push(p);
+  }
+  return out;
 }
 
 // ../daemon/src/files/vite-offset.ts
@@ -18236,12 +18847,13 @@ class FileService {
   }
   async list(worktreeId) {
     const cwd = this.require(worktreeId).path;
-    const [staged, untracked, deleted] = await Promise.all([
+    const [staged, untracked, deleted, ignored] = 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", "-d"),
+      git(cwd, "ls-files", "-z", "-o", "-i", "--exclude-standard", "--directory")
     ]);
-    return parseListing(staged.out, untracked.out, deleted.out);
+    return parseListing(staged.out, untracked.out, deleted.out, ignored.out);
   }
   async search(worktreeId, query) {
     const { path: cwd } = this.require(worktreeId);
@@ -18464,6 +19076,7 @@ class AfterLand {
     fireAndForget(repo.id, done, "afterLand");
   }
   async exec(repo, commands) {
+    await this.d.settled?.();
     if (this.d.self.building(true))
       this.d.hub.emit("selfChanged");
     let failure;
@@ -18504,41 +19117,18 @@ class AfterLand {
 }
 
 // ../daemon/src/repos/registry.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync5, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync6, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir7 } from "os";
-import { basename as basename3, dirname as dirname6, join as join14 } from "path";
-
-// ../daemon/src/worktrees/naming.ts
-import { randomBytes as randomBytes2 } from "crypto";
-function shortId() {
-  return randomBytes2(5).toString("hex");
-}
-function slugify2(prompt, withRandom = true) {
-  const words = prompt.toLowerCase().replace(/[^a-z0-9\s-]/g, "").split(/\s+/).filter(Boolean).slice(0, 3);
-  const base = words.join("-").slice(0, 20).replace(/-+$/g, "") || "task";
-  return withRandom ? `${base}-${randomBytes2(2).toString("hex")}` : base;
-}
-function cleanTitle2(title) {
-  return title.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
-}
-var VARIANT_LENSES = [
-  "Take the most direct approach: the change most people would expect, in the smallest diff.",
-  "Lean toward how it looks and reads: polish what the task touches using only the design tokens, components and voice the project already has. Add no new colours, fonts or effects, and restyle nothing outside the task.",
-  "Lean toward behaviour: edge cases, empty and error states, and what can go wrong, over visual change."
-];
-function variantLens(index) {
-  const lens = VARIANT_LENSES[(index - 1) % VARIANT_LENSES.length];
-  return `(You are attempt ${index} of several parallel attempts at this task. Stay within the task and follow the project's existing styles, components, tokens and writing conventions; the attempts differ in emphasis, not in how much they change. ${lens})`;
-}
+import { basename as basename3, dirname as dirname6, join as join16 } from "path";
 
 // ../daemon/src/repos/browse.ts
-import { existsSync as existsSync13, statSync as statSync3 } from "fs";
+import { existsSync as existsSync15, statSync as statSync3 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join10 } from "path";
+import { dirname as dirname4, join as join12 } from "path";
 var MAX_ENTRIES = 40;
 function expandTilde(raw) {
-  return raw === "~" || raw.startsWith("~/") ? join10(homedir5(), raw.slice(1)) : raw;
+  return raw === "~" || raw.startsWith("~/") ? join12(homedir5(), raw.slice(1)) : raw;
 }
 function collapseTilde(abs) {
   const home = homedir5();
@@ -18549,7 +19139,7 @@ function holdsNothing(names) {
 }
 async function describeFolder(abs) {
   const path = collapseTilde(abs);
-  if (existsSync13(join10(abs, ".git")))
+  if (existsSync15(join12(abs, ".git")))
     return { path, kind: "project" };
   try {
     return { path, kind: holdsNothing(await readdir(abs)) ? "empty" : "folder" };
@@ -18564,10 +19154,10 @@ function describe2(typed, parent) {
     isDir = statSync3(typed).isDirectory();
   } catch {}
   return {
-    exists: existsSync13(typed),
+    exists: existsSync15(typed),
     isDir,
-    isRepo: isDir && existsSync13(join10(typed, ".git")),
-    parentExists: existsSync13(parent)
+    isRepo: isDir && existsSync15(join12(typed, ".git")),
+    parentExists: existsSync15(parent)
   };
 }
 async function browsePath(raw) {
@@ -18591,16 +19181,16 @@ async function browsePath(raw) {
       continue;
     if (!name.toLowerCase().startsWith(prefix))
       continue;
-    const abs = join10(dir, name);
-    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync13(join10(abs, ".git")) });
+    const abs = join12(dir, name);
+    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync15(join12(abs, ".git")) });
   }
   entries.sort((a, b) => a.isRepo !== b.isRepo ? a.isRepo ? -1 : 1 : a.name.localeCompare(b.name));
   return { entries: entries.slice(0, MAX_ENTRIES), target };
 }
 
 // ../daemon/src/repos/config.ts
-import { closeSync, existsSync as existsSync14, openSync as openSync2, readdirSync as readdirSync3, readFileSync as readFileSync10, readSync } from "fs";
-import { join as join11 } from "path";
+import { closeSync, existsSync as existsSync16, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync11, readSync } from "fs";
+import { join as join13 } from "path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -19964,7 +20554,7 @@ function applyEdits(text, edits) {
 
 // ../daemon/src/repos/config.ts
 var PLACES = [CONFIG_FILES.folder, CONFIG_FILES.root];
-var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync14(join11(repoPath, rel)));
+var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync16(join13(repoPath, rel)));
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function parseSettings(text) {
   const errors = [];
@@ -19989,7 +20579,7 @@ function readConfigFile(repoPath) {
   for (const rel of files) {
     let raw;
     try {
-      raw = parseSettings(readFileSync10(join11(repoPath, rel), "utf8"));
+      raw = parseSettings(readFileSync11(join13(repoPath, rel), "utf8"));
     } catch (e) {
       return { ok: false, reason: `${rel} is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
     }
@@ -20046,12 +20636,12 @@ function configTarget(repoPath, made) {
 }
 function configBody(repoPath, rel, config) {
   const place = PLACES.find((p) => p.local === rel);
-  const abs = place && join11(repoPath, place.shared);
-  if (!abs || !existsSync14(abs))
+  const abs = place && join13(repoPath, place.shared);
+  if (!abs || !existsSync16(abs))
     return config;
   let shared;
   try {
-    shared = parseSettings(readFileSync10(abs, "utf8"));
+    shared = parseSettings(readFileSync11(abs, "utf8"));
   } catch {
     return config;
   }
@@ -20064,7 +20654,7 @@ function configText(repoPath, rel, config) {
   let text;
   let was;
   try {
-    text = readFileSync10(join11(repoPath, rel), "utf8");
+    text = readFileSync11(join13(repoPath, rel), "utf8");
     was = parseSettings(text);
   } catch {
     return fresh;
@@ -20094,9 +20684,9 @@ function detectConfig(repoPath) {
     return { config: explicit.config, needsSetup: false };
   if (explicit)
     log.warn("config", `${repoPath}: ${explicit.reason}; detecting instead`);
-  const pkgPath = join11(repoPath, "package.json");
-  if (existsSync14(pkgPath)) {
-    const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+  const pkgPath = join13(repoPath, "package.json");
+  if (existsSync16(pkgPath)) {
+    const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
     const runner = detectRunner(repoPath, pkg.packageManager);
     const pages = detectPages(repoPath, scripts, runner);
@@ -20117,7 +20707,7 @@ function detectConfig(repoPath) {
       };
     }
   }
-  if (existsSync14(join11(repoPath, "start.sh"))) {
+  if (existsSync16(join13(repoPath, "start.sh"))) {
     return { config: { run: { app: "./start.sh" } }, needsSetup: true, from: "start.sh" };
   }
   const assumed = assumeNothingToRun(repoPath);
@@ -20160,24 +20750,24 @@ function assumeNothingToRun(repoPath) {
   return marker && !servesPage(repoPath) ? marker : undefined;
 }
 function markerIn(repoPath) {
-  const named = NO_PAGE_MARKERS.find((f) => existsSync14(join11(repoPath, f)));
+  const named = NO_PAGE_MARKERS.find((f) => existsSync16(join13(repoPath, f)));
   if (named)
     return named;
   let entries;
   try {
-    entries = readdirSync3(repoPath);
+    entries = readdirSync4(repoPath);
   } catch {
     return;
   }
   return entries.find((f) => NO_PAGE_EXTENSIONS.some((ext) => f.endsWith(ext)));
 }
 function servesPage(repoPath) {
-  if (WEB_FILES.some((f) => existsSync14(join11(repoPath, f))))
+  if (WEB_FILES.some((f) => existsSync16(join13(repoPath, f))))
     return true;
-  if (/^web:/m.test(head(join11(repoPath, "Procfile"))))
+  if (/^web:/m.test(head(join13(repoPath, "Procfile"))))
     return true;
   for (const [files, names] of WEB_DEPENDENCIES) {
-    const text = files.map((f) => head(join11(repoPath, f))).join(`
+    const text = files.map((f) => head(join13(repoPath, f))).join(`
 `);
     if (text.trim() && names.some((n) => mentions(text, n)))
       return true;
@@ -20187,14 +20777,14 @@ function servesPage(repoPath) {
 function frontEndBeside(repoPath) {
   let dirs;
   try {
-    dirs = readdirSync3(repoPath, { withFileTypes: true });
+    dirs = readdirSync4(repoPath, { withFileTypes: true });
   } catch {
     return false;
   }
   return dirs.some((d) => {
     if (!d.isDirectory() || d.name.startsWith(".") || NOT_A_PACKAGE.has(d.name))
       return false;
-    const pkg = head(join11(repoPath, d.name, "package.json"));
+    const pkg = head(join13(repoPath, d.name, "package.json"));
     if (!pkg)
       return false;
     try {
@@ -20209,7 +20799,7 @@ function mentions(text, name) {
   return new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i").test(text);
 }
 function head(path) {
-  if (!existsSync14(path))
+  if (!existsSync16(path))
     return "";
   try {
     const fd = openSync2(path, "r");
@@ -20237,31 +20827,31 @@ function procCommand(runner, script, body) {
   return `${base}${runner === "npm" ? " --" : ""} ${flag}`;
 }
 function detectPages(repoPath, scripts, runner) {
-  if (!scripts.build || !existsSync14(join11(repoPath, "functions")))
+  if (!scripts.build || !existsSync16(join13(repoPath, "functions")))
     return null;
-  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join11(repoPath, f)).find((f) => existsSync14(f));
+  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join13(repoPath, f)).find((f) => existsSync16(f));
   if (!cfg)
     return null;
-  const out = readFileSync10(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
+  const out = readFileSync11(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
   if (!out)
     return null;
   return { web: `${runner} run build && npx wrangler pages dev ${out} --ip 127.0.0.1 --port $PORT` };
 }
 function detectRunner(repoPath, packageManager) {
-  if (existsSync14(join11(repoPath, "bun.lock")) || existsSync14(join11(repoPath, "bun.lockb")))
+  if (existsSync16(join13(repoPath, "bun.lock")) || existsSync16(join13(repoPath, "bun.lockb")))
     return "bun";
-  if (existsSync14(join11(repoPath, "pnpm-lock.yaml")))
+  if (existsSync16(join13(repoPath, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync14(join11(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
+  if (existsSync16(join13(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
     return "yarn";
   return "npm";
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync15, readdirSync as readdirSync4, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync5, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import { appendFile as appendFile2, mkdir as mkdir2, rm } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname5, join as join12, resolve as resolve7 } from "path";
+import { dirname as dirname5, join as join14, resolve as resolve7 } from "path";
 function isInside(dir, parent) {
   const p = parent.replace(/\/+$/, "");
   return dir === p || dir.startsWith(`${p}/`);
@@ -20272,29 +20862,29 @@ function planProject(opts, home = homedir6()) {
     throw new UserError(nameError);
   const first = firstProjectsFolder(opts.parent, home);
   const parent = first ?? resolveParent(opts.parent);
-  const dir = join12(parent, opts.name.trim());
-  if (existsSync15(dir))
+  const dir = join14(parent, opts.name.trim());
+  if (existsSync17(dir))
     throw new UserError(`${dir} already exists`);
   return { parent, dir, makeParent: first !== null };
 }
 function firstProjectsFolder(raw, home) {
   const typed = expandTilde(raw.trim()).replace(/\/+$/, "");
-  if (typed !== join12(home, PROJECTS_FOLDER) || existsSync15(typed) || !existsSync15(home))
+  if (typed !== join14(home, PROJECTS_FOLDER) || existsSync17(typed) || !existsSync17(home))
     return null;
-  return join12(realpathSync2(home), PROJECTS_FOLDER);
+  return join14(realpathSync2(home), PROJECTS_FOLDER);
 }
 function planInPlace(opts) {
   const name = opts.name.trim();
   if (!name || name === "." || name === ".." || name.includes("/")) {
     throw new UserError(`${opts.name} is not a folder name`);
   }
-  const typed = join12(resolveParent(opts.parent), name);
-  if (!existsSync15(typed) || !statSync4(typed).isDirectory())
+  const typed = join14(resolveParent(opts.parent), name);
+  if (!existsSync17(typed) || !statSync4(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
-  if (existsSync15(join12(dir, ".git")))
+  if (existsSync17(join14(dir, ".git")))
     throw new UserError(`${dir} is already a project; open it instead`);
-  if (!holdsNothing(readdirSync4(dir))) {
+  if (!holdsNothing(readdirSync5(dir))) {
     throw new UserError(`${dir} is not empty; only an empty folder can become a project where it is`);
   }
   return { parent: dirname5(dir), dir, makeParent: false };
@@ -20303,7 +20893,7 @@ function resolveParent(raw) {
   const typed = expandTilde(raw.trim());
   if (!typed.startsWith("/"))
     throw new UserError(`${raw} is not a folder path`);
-  if (!existsSync15(typed))
+  if (!existsSync17(typed))
     throw new UserError(`${raw} does not exist; make it first`);
   if (!statSync4(typed).isDirectory())
     throw new UserError(`${raw} is not a folder`);
@@ -20383,13 +20973,13 @@ async function undoCreate(dir) {
 }
 async function undoInit(dir) {
   try {
-    await rm(join12(dir, ".git"), { recursive: true, force: true });
+    await rm(join14(dir, ".git"), { recursive: true, force: true });
   } catch (e) {
     log.warn(dir, "could not take back a half-made .git", e);
   }
 }
 async function unmakeProject(dir, made) {
-  const target = made === "folder" ? dir : join12(dir, ".git");
+  const target = made === "folder" ? dir : join14(dir, ".git");
   try {
     await rm(target, { recursive: true, force: true });
   } catch (e) {
@@ -20419,8 +21009,8 @@ async function ok(p, what) {
 }
 
 // ../daemon/src/repos/watcher.ts
-import { existsSync as existsSync16, watch } from "fs";
-import { basename as basename2, join as join13 } from "path";
+import { existsSync as existsSync18, watch } from "fs";
+import { basename as basename2, join as join15 } from "path";
 function watchDefaultBranch(repoPath, branch, onMove) {
   let last = null;
   fireAndForget(repoPath, git(repoPath, "rev-parse", branch).then((r) => {
@@ -20450,8 +21040,8 @@ function watchDefaultBranch(repoPath, branch, onMove) {
       log.debug(repoPath, `not watching ${p}`, e);
     }
   };
-  tryWatch(join13(repoPath, ".git"));
-  tryWatch(join13(repoPath, ".git", "refs", "heads"));
+  tryWatch(join15(repoPath, ".git"));
+  tryWatch(join15(repoPath, ".git", "refs", "heads"));
   return () => {
     for (const w of watchers)
       w.close();
@@ -20473,7 +21063,7 @@ function watchWorktreeDir(repoPath, onChange) {
     }, 300);
   };
   const arm = (commonDir) => {
-    const dir = join13(commonDir, "worktrees");
+    const dir = join15(commonDir, "worktrees");
     const armInner = () => {
       inner?.close();
       inner = null;
@@ -20516,7 +21106,7 @@ function watchWorktreeDir(repoPath, onChange) {
 function watchConfigFile(repoPath, onChange) {
   const atRoot = new Set([CONFIG_FILES.root.shared, CONFIG_FILES.root.local, CONFIG_DIR]);
   const inDir = new Set([CONFIG_FILES.folder.shared, CONFIG_FILES.folder.local].map((rel) => basename2(rel)));
-  const dir = join13(repoPath, CONFIG_DIR);
+  const dir = join15(repoPath, CONFIG_DIR);
   let timer = null;
   let outer = null;
   let inner = null;
@@ -20531,7 +21121,7 @@ function watchConfigFile(repoPath, onChange) {
   const armInner = () => {
     inner?.close();
     inner = null;
-    if (!existsSync16(dir))
+    if (!existsSync18(dir))
       return;
     try {
       inner = watch(dir, (_event, filename) => {
@@ -20585,7 +21175,7 @@ class RepoRegistry {
   }
   async boot() {
     const { state } = this.d;
-    const gone = state.worktrees.filter((wt) => !existsSync17(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
+    const gone = state.worktrees.filter((wt) => !existsSync19(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
     for (const wt of gone)
       await this.d.worktrees.forgetGone(wt);
     for (const repo of state.repos) {
@@ -20652,7 +21242,7 @@ class RepoRegistry {
       return `${repo.name} is set up now`;
     if (main.promptedAt || main.lastTurn)
       return `${repo.name} has a chat now`;
-    if (existsSync17(join14(repo.path, ".claude")))
+    if (existsSync19(join16(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`;
@@ -20729,7 +21319,7 @@ class RepoRegistry {
   }
   async register(rawPath, made) {
     const path = expandTilde(rawPath);
-    if (!existsSync17(path))
+    if (!existsSync19(path))
       throw new UserError(`${path} does not exist`);
     if (!await isGitRepo(path))
       throw new UserError(`${path} is not a git repository`);
@@ -20767,7 +21357,6 @@ class RepoRegistry {
     };
     this.d.state.addWorktree(main);
     this.warmed.add(repo.id);
-    await this.d.runtime.start(main, repo);
     this.startWatcher(repo);
     fireAndForget(repo.id, this.d.worktrees.spare.ensure(repo.id), "spare warm-up");
     this.d.hub.emit("reposChanged");
@@ -20789,8 +21378,8 @@ class RepoRegistry {
       this.d.state.removeWorktree(wt.id);
       this.d.worktrees.deleteChat(wt.id);
       releasePort(wt.proxyPort);
+      this.d.drafts?.drop(wt.id);
     }
-    this.d.drafts?.drop(draftKey(repoId));
     this.d.state.removeRepo(repoId);
     this.d.hub.emit("reposChanged");
     this.d.hub.emit("worktreesChanged");
@@ -20802,10 +21391,10 @@ class RepoRegistry {
       throw new UserError(current.reason);
     const was = configTarget(repo.path, !!repo.made);
     const rel = configSibling(was, kind);
-    const moved = rel !== was && existsSync17(join14(repo.path, was));
+    const moved = rel !== was && existsSync19(join16(repo.path, was));
     if (moved && !(kind === "local" && await isTracked(repo.path, was))) {
       try {
-        rmSync2(join14(repo.path, was));
+        rmSync2(join16(repo.path, was));
       } catch (e) {
         log.warn(repoId, `could not remove ${was}`, e);
       }
@@ -20814,10 +21403,10 @@ class RepoRegistry {
     }
     if (isLocalConfigFile(rel))
       await excludeFromGit(repo.path, rel);
-    const file = join14(repo.path, rel);
+    const file = join16(repo.path, rel);
     try {
-      mkdirSync5(dirname6(file), { recursive: true });
-      writeFileSync6(file, configText(repo.path, rel, config));
+      mkdirSync6(dirname6(file), { recursive: true });
+      writeFileSync7(file, configText(repo.path, rel, config));
     } catch (e) {
       log.warn(repoId, `could not write ${rel}`, e);
     }
@@ -20829,7 +21418,7 @@ class RepoRegistry {
     repo.assumed = undefined;
     this.d.state.save();
     this.warmed.add(repoId);
-    for (const wt of this.d.state.worktrees.filter((w) => w.repoId === repoId)) {
+    for (const wt of this.d.state.worktrees.filter((w) => w.repoId === repoId && (w.kind !== "main" || this.d.runtime.get(w.id)?.procs))) {
       fireAndForget(wt.id, this.d.runtime.stopProcs(wt.id).then(() => this.d.runtime.start(wt, repo)), "runtime restart");
     }
     fireAndForget(repoId, this.d.worktrees.spare.ensure(repoId), "spare warm-up");
@@ -20891,7 +21480,7 @@ class RepoRegistry {
   }
   placeConfig(repo) {
     const rel = configTarget(repo.path, !!repo.made);
-    if (isLocalConfigFile(rel) && existsSync17(join14(repo.path, rel))) {
+    if (isLocalConfigFile(rel) && existsSync19(join16(repo.path, rel))) {
       fireAndForget(repo.id, excludeFromGit(repo.path, rel), "exclude local settings");
     }
     if (repo.configFile === rel)
@@ -20966,7 +21555,7 @@ class RepoRegistry {
 }
 
 // ../daemon/src/routes/service.ts
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 
 // ../daemon/src/routes/fileRouters.ts
 var SKIP = /(^|\/)(node_modules|dist|build|out|coverage|\.next|\.nuxt|\.output|\.svelte-kit|\.vercel|\.netlify)\//;
@@ -22166,7 +22755,7 @@ class RouteService {
     return mergeRoutes(fileRoutes(paths, roots), code);
   }
   async cachedRead(root, path, had, kept, decode) {
-    const abs = join15(root, path);
+    const abs = join17(root, path);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -22191,7 +22780,7 @@ class RouteService {
     }
   }
   async hash(root, file) {
-    const abs = join15(root, file);
+    const abs = join17(root, file);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -22235,7 +22824,7 @@ class RouteService {
 }
 
 // ../daemon/src/runtime/bridge-script.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11, statSync as statSync5 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync12, statSync as statSync5 } from "fs";
 var LEARNED_MAX = 8;
 
 class BridgeScript {
@@ -22265,7 +22854,7 @@ class BridgeScript {
     this.cache = null;
   }
   get() {
-    if (!existsSync18(this.path))
+    if (!existsSync20(this.path))
       return "// toyon bridge not built";
     const s = statSync5(this.path);
     const stamp = `${s.mtimeMs}:${s.size}`;
@@ -22274,7 +22863,7 @@ class BridgeScript {
     this.stamp = stamp;
     const origins = [...this.origins, ...this.learned];
     this.cache = `window.__toyonShellOrigins=${JSON.stringify(origins)};
-${readFileSync11(this.path, "utf8")}`;
+${readFileSync12(this.path, "utf8")}`;
     return this.cache;
   }
 }
@@ -22291,70 +22880,6 @@ function servedLocally(origin) {
   return h === "127.0.0.1" || h === "localhost" || h === "::1" || h === "[::1]" || h.endsWith(".localhost");
 }
 
-// ../daemon/src/runtime/memory.ts
-var MAC_PRESSURE_CRITICAL = 4;
-var AVAILABLE_FLOOR = 0.15;
-var unsupportedLogged = false;
-async function memoryTight() {
-  const signal = process.platform === "darwin" ? await darwin() : process.platform === "linux" ? await linux() : null;
-  if (signal === null && !unsupportedLogged) {
-    unsupportedLogged = true;
-    log.warn("memory", `no memory pressure reading on ${process.platform}; nothing sleeps for memory`);
-  }
-  return signal;
-}
-async function darwin() {
-  const r = await run("sysctl", ["-n", "kern.memorystatus_vm_pressure_level", "kern.memorystatus_level"], "/");
-  if (!r.ok)
-    return null;
-  const [level, available] = r.out.split(/\s+/).map(Number);
-  if (level === undefined || available === undefined || Number.isNaN(level) || Number.isNaN(available))
-    return null;
-  return darwinSignal(level, available);
-}
-function darwinSignal(level, available) {
-  const pressure = level === 1 ? "normal" : level === 2 ? "warn" : level === MAC_PRESSURE_CRITICAL ? "critical" : `level ${level}`;
-  return {
-    tight: level === MAC_PRESSURE_CRITICAL || available < AVAILABLE_FLOOR * 100,
-    why: `memory pressure ${pressure} with ${available}% available`
-  };
-}
-async function linux() {
-  let text;
-  try {
-    text = await Bun.file("/proc/meminfo").text();
-  } catch {
-    return null;
-  }
-  const field = (name) => {
-    const m = text.match(new RegExp(`^${name}:\\s+(\\d+)`, "m"));
-    return m ? Number(m[1]) : null;
-  };
-  const total = field("MemTotal");
-  const available = field("MemAvailable");
-  if (!total || available === null)
-    return null;
-  const percent = Math.round(available / total * 100);
-  return { tight: available / total < AVAILABLE_FLOOR, why: `${percent}% of memory available` };
-}
-async function sampleCosts(pgids) {
-  const costs = new Map;
-  if (pgids.length === 0)
-    return costs;
-  const wanted = new Set(pgids);
-  const r = await run("ps", ["-axo", "pgid=,rss="], "/");
-  if (!r.ok)
-    return costs;
-  for (const line of r.out.split(`
-`)) {
-    const [pgid, rss] = line.trim().split(/\s+/).map(Number);
-    if (pgid === undefined || rss === undefined || !wanted.has(pgid))
-      continue;
-    costs.set(pgid, (costs.get(pgid) ?? 0) + rss);
-  }
-  return costs;
-}
-
 // ../daemon/src/runtime/idle.ts
 var LOCAL_SLEEP_MS = 2 * 60 * 60000;
 var CLOUD_SLEEP_MS = 5 * 60000;
@@ -22377,6 +22902,7 @@ class IdlePolicy {
   viewing = new Map;
   queue = [];
   draining = false;
+  drained = [];
   sleepMs;
   now;
   constructor(d) {
@@ -22470,6 +22996,9 @@ class IdlePolicy {
     const wt = this.d.state.worktree(id);
     return !!wt && this.now() - (wt.viewedAt ?? 0) < (this.sleepMs ?? LOCAL_SLEEP_MS);
   }
+  isShown(id) {
+    return (this.entries.get(id)?.viewers.size ?? 0) > 0;
+  }
   isViewed(id) {
     if ((this.entries.get(id)?.viewers.size ?? 0) > 0)
       return true;
@@ -22492,7 +23021,8 @@ class IdlePolicy {
     const pick = this.d.state.worktrees.filter((w) => this.candidate(w.id)).sort((a, b) => this.entry(a.id).activeAt - this.entry(b.id).activeAt)[0];
     if (!pick)
       return;
-    this.sleep(pick.id, `${signal.why}; least recently used`);
+    log.info("idle", `${signal.why}; ${pick.id} is the least recently used`);
+    this.sleep(pick.id, "short of memory");
   }
   async sampleCosts() {
     this.recordViewed();
@@ -22590,13 +23120,12 @@ class IdlePolicy {
       this.arm(id, this.sleepMs - idle);
       return;
     }
-    this.sleep(id, `idle ${humanMs(this.sleepMs)}`);
+    this.sleep(id, `nobody looked for ${humanMs(this.sleepMs)}`);
   }
   sleep(id, why) {
     this.disarm(id);
     this.entry(id).costKb = undefined;
-    log.info(id, `asleep: ${why}`);
-    fireAndForget(id, this.d.runtime.sleep(id), "sleep");
+    fireAndForget(id, this.d.runtime.sleep(id, why), "sleep");
   }
   enqueue(key, run) {
     if (this.queue.some((q) => q.key === key))
@@ -22612,15 +23141,22 @@ class IdlePolicy {
         await next.run();
     } finally {
       this.draining = false;
+      for (const r of this.drained.splice(0))
+        r();
     }
   }
+  settled() {
+    if (!this.draining)
+      return Promise.resolve();
+    return new Promise((r) => this.drained.push(r));
+  }
 }
 function humanMs(ms) {
   if (ms >= 60 * 60000 && ms % (60 * 60000) === 0)
-    return `${ms / (60 * 60000)}h`;
+    return `${ms / (60 * 60000)} h`;
   if (ms >= 60000)
     return `${Math.round(ms / 60000)} min`;
-  return `${Math.round(ms / 1000)}s`;
+  return `${Math.round(ms / 1000)} s`;
 }
 
 // ../daemon/src/server/ws.ts
@@ -22647,50 +23183,50 @@ class PairCodes {
 }
 
 // ../daemon/src/agent/config.ts
-import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 function agentConfigFiles(spec, repoPath, home = homedir8()) {
   const file = (id, label, path) => ({
     id,
     label,
     path,
-    exists: existsSync19(path)
+    exists: existsSync21(path)
   });
   if (spec.id === "claude") {
     return [
-      file("user-config", "user config (MCP servers, projects)", join16(home, ".claude.json")),
-      file("user-settings", "user settings (permissions, hooks)", join16(home, ".claude", "settings.json")),
-      ...repoPath ? [file("project-mcp", "project MCP servers", join16(repoPath, ".mcp.json"))] : [],
-      ...repoPath ? [file("project-settings", "project settings", join16(repoPath, ".claude", "settings.json"))] : []
+      file("user-config", "user config (MCP servers, projects)", join18(home, ".claude.json")),
+      file("user-settings", "user settings (permissions, hooks)", join18(home, ".claude", "settings.json")),
+      ...repoPath ? [file("project-mcp", "project MCP servers", join18(repoPath, ".mcp.json"))] : [],
+      ...repoPath ? [file("project-settings", "project settings", join18(repoPath, ".claude", "settings.json"))] : []
     ];
   }
   if (spec.id === "codex")
-    return [file("user-config", "config", join16(home, ".codex", "config.toml"))];
+    return [file("user-config", "config", join18(home, ".codex", "config.toml"))];
   return [];
 }
 function describeAgentConfig(spec, repoPath, home = homedir8()) {
   const files = agentConfigFiles(spec, repoPath, home);
   const servers = [];
   if (spec.id === "claude") {
-    const user = readJson(join16(home, ".claude.json"));
+    const user = readJson(join18(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(join16(repoPath, ".mcp.json"))?.mcpServers, "project"));
+      servers.push(...serversOf(readJson(join18(repoPath, ".mcp.json"))?.mcpServers, "project"));
     }
   } else if (spec.id === "codex") {
-    servers.push(...codexServers(join16(home, ".codex", "config.toml")));
+    servers.push(...codexServers(join18(home, ".codex", "config.toml")));
   }
   return { agent: spec.id, files, servers };
 }
 function readJson(path) {
-  if (!existsSync19(path))
+  if (!existsSync21(path))
     return null;
   try {
-    const v = JSON.parse(readFileSync12(path, "utf8"));
+    const v = JSON.parse(readFileSync13(path, "utf8"));
     return v && typeof v === "object" && !Array.isArray(v) ? v : null;
   } catch (e) {
     log.warn("agent-config", `${path} is not valid JSON`, e);
@@ -22708,11 +23244,11 @@ function serversOf(raw, scope) {
   });
 }
 function codexServers(path) {
-  if (!existsSync19(path))
+  if (!existsSync21(path))
     return [];
   const out = [];
   let current = null;
-  for (const raw of readFileSync12(path, "utf8").split(`
+  for (const raw of readFileSync13(path, "utf8").split(`
 `)) {
     const line = raw.trim();
     const header = /^\[mcp_servers\.("?)([^\]"]+)\1\]$/.exec(line);
@@ -23304,8 +23840,11 @@ var handlers = {
   unsubscribe(msg, ctx) {
     ctx.unsubscribe(msg.worktreeId);
   },
-  view(msg, ctx) {
+  view(msg, ctx, s) {
     ctx.view(msg.worktreeId);
+    const wt = msg.worktreeId ? s.state.worktree(msg.worktreeId) : undefined;
+    if (wt && isLead(wt))
+      fireAndForget(wt.repoId, s.worktrees.syncTrunk(wt.repoId), "trunk sync");
   },
   seen(msg, _ctx, s) {
     s.turns.markSeen(msg.worktreeId);
@@ -23315,6 +23854,7 @@ var handlers = {
   },
   "set-draft"(msg, _ctx, s) {
     s.drafts.set(msg.boxId, msg.text, msg.clientId);
+    s.worktrees.spare.typed(msg.boxId, msg.text);
   },
   "refresh-git"(msg, _ctx, s) {
     s.worktrees.recount(msg.repoId);
@@ -23339,6 +23879,7 @@ var handlers = {
   async "create-worktree"(msg, _ctx, s) {
     await s.worktrees.create(msg.repoId, msg.prompt, {
       createdBy: msg.clientId,
+      worktreeId: msg.worktreeId,
       variant: msg.variant,
       context: msg.context,
       attachments: msg.attachments,
@@ -23462,6 +24003,9 @@ var handlers = {
   "update-now"(_msg, _ctx, s) {
     return s.update.updateNow();
   },
+  "check-update"(_msg, _ctx, s) {
+    return s.update.checkNow();
+  },
   async commit(msg, ctx, s) {
     const result = await s.worktrees.commit(msg.worktreeId, msg.message);
     await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message));
@@ -23516,6 +24060,10 @@ var handlers = {
   async "discard-file"(msg, _ctx, s) {
     await s.files.discard(msg.worktreeId, msg.path);
     s.hub.emit("filesChanged", msg.worktreeId);
+    s.landing.recheck(msg.worktreeId);
+  },
+  async judge(msg, _ctx, s) {
+    await s.landing.judge(msg.worktreeId);
   },
   async "write-file"(msg, ctx, s) {
     const head = { t: "file-written", worktreeId: msg.worktreeId, path: msg.path, seq: msg.seq };
@@ -23698,8 +24246,8 @@ async function dispatch(msg, ctx, s) {
 }
 
 // ../daemon/src/server/http.ts
-import { existsSync as existsSync20 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { join as join19 } from "path";
 var IMMUTABLE = "private, max-age=31536000, immutable";
 var NO_STORE = "no-store";
 function createFetch(opts) {
@@ -23769,10 +24317,12 @@ function createFetch(opts) {
         headers["set-cookie"] = grantCookie(grant, remote.host);
       return Response.json(await opts.bootstrap(), { headers });
     }
-    if (url.pathname === "/restart" && req.method === "POST") {
+    if (url.pathname === "/restart" && (req.method === "POST" || req.method === "GET")) {
       if (!sameSecret(url.searchParams.get("token"), opts.token))
         return new Response("unauthorized", { status: 401 });
-      const refused = opts.restart();
+      if (req.method === "GET")
+        return Response.json(opts.restartWait(), { headers: { "cache-control": NO_STORE } });
+      const refused = opts.restart(url.searchParams.has(RESTART_NOW));
       return refused ? new Response(refused, { status: 409 }) : new Response(null, { status: 202 });
     }
     if (url.pathname === "/pair" && req.method === "POST") {
@@ -23821,7 +24371,7 @@ function createFetch(opts) {
         return new Response("unauthorized", { status: 401 });
       const [worktreeId, file, extra] = url.pathname.slice("/attachments/".length).split("/");
       const places = worktreeId && file && !extra ? [opts.attachments.fileFor(worktreeId, file), opts.archivedAttachment(worktreeId, file)] : [];
-      const path = places.find((p) => !!p && existsSync20(p));
+      const path = places.find((p) => !!p && existsSync22(p));
       if (!path)
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), { headers: { "cache-control": IMMUTABLE } });
@@ -23842,15 +24392,15 @@ function createFetch(opts) {
       });
     }
     const rel = url.pathname === "/" ? "/index.html" : url.pathname;
-    const file = join17(opts.shellDist, rel.replaceAll("..", ""));
+    const file = join19(opts.shellDist, rel.replaceAll("..", ""));
     const hashed = rel.startsWith("/assets/");
-    if (existsSync20(file) && Bun.file(file).size > 0) {
+    if (existsSync22(file) && Bun.file(file).size > 0) {
       return new Response(Bun.file(file), { headers: { "cache-control": hashed ? IMMUTABLE : NO_STORE } });
     }
     if (hashed)
       return new Response("not found", { status: 404 });
-    const index = join17(opts.shellDist, "index.html");
-    if (existsSync20(index))
+    const index = join19(opts.shellDist, "index.html");
+    if (existsSync22(index))
       return new Response(Bun.file(index), { headers: { "cache-control": NO_STORE } });
     return new Response("Toyon daemon running; shell not built (run: bun run build)", { status: 200 });
   };
@@ -23962,7 +24512,7 @@ function startServer(opts) {
     fireAndForget("ws", (async () => {
       do {
         statusesDirty = false;
-        broadcast({ t: "worktrees", rows: await s.worktrees.rows(), spares: s.worktrees.spares() });
+        broadcast({ t: "worktrees", rows: await s.worktrees.rows(), trunks: await s.worktrees.trunks() });
       } while (statusesDirty);
     })().finally(() => {
       statusesInFlight = false;
@@ -24068,10 +24618,11 @@ function startServer(opts) {
     return {
       t: "hello",
       version,
+      install: s.update.install(),
       protocol: PROTOCOL_VERSION,
       repos: s.state.repos,
       rows: await s.worktrees.rows({ quick: true }),
-      spares: s.worktrees.spares(),
+      trunks: await s.worktrees.trunks({ quick: true }),
       themes: s.themes.themes,
       themePrefs: s.themes.prefs,
       agents: agentInfos(),
@@ -24106,7 +24657,8 @@ function startServer(opts) {
       remote: opts.remote,
       preview: (id) => s.runtime.get(id)?.proxy?.handler ?? null,
       bootstrap: helloFrame,
-      restart: () => s.restarter.request(),
+      restart: (now) => s.restarter.request({ now }),
+      restartWait: () => ({ waiting: s.restarter.waitingOn(), asking: s.restarter.asking() }),
       pair: new PairCodes,
       onPaired: () => {
         s.state.notePaired();
@@ -24218,16 +24770,16 @@ function startServer(opts) {
 }
 
 // ../daemon/src/themes/store.ts
-import { existsSync as existsSync21, readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync6, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir10 } from "os";
-import { basename as basename4, dirname as dirname7, join as join18, resolve as resolve8 } from "path";
+import { basename as basename4, dirname as dirname7, join as join20, resolve as resolve8 } from "path";
 var home = homedir10();
 var defaultExtensionDirs = [
-  join18(home, ".vscode", "extensions"),
-  join18(home, ".vscode-insiders", "extensions"),
-  join18(home, ".vscode-oss", "extensions"),
-  join18(home, ".cursor", "extensions"),
-  join18(home, ".windsurf", "extensions"),
+  join20(home, ".vscode", "extensions"),
+  join20(home, ".vscode-insiders", "extensions"),
+  join20(home, ".vscode-oss", "extensions"),
+  join20(home, ".cursor", "extensions"),
+  join20(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",
@@ -24311,14 +24863,14 @@ class ThemeStore {
       name: json?.name ?? base,
       source: "file"
     });
-    writeFileSync7(join18(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
+    writeFileSync8(join20(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
 `);
     this.load();
     return theme;
   }
 }
 function readJsonc(file) {
-  return parse6(readFileSync13(file, "utf8"), [], { allowTrailingComma: true });
+  return parse6(readFileSync14(file, "utf8"), [], { allowTrailingComma: true });
 }
 function readVscodeTheme(file, depth = 0) {
   const json = readJsonc(file);
@@ -24340,13 +24892,13 @@ function readVscodeTheme(file, depth = 0) {
   return t;
 }
 function loadDir(dir) {
-  if (!existsSync21(dir))
+  if (!existsSync23(dir))
     return [];
   const out = [];
-  for (const f of readdirSync5(dir)) {
+  for (const f of readdirSync6(dir)) {
     if (!/\.jsonc?$/i.test(f))
       continue;
-    const file = join18(dir, f);
+    const file = join20(dir, f);
     const id = `file:${slug(f.replace(/\.(json|jsonc)$/i, ""))}`;
     try {
       const json = readJsonc(file);
@@ -24362,31 +24914,31 @@ function loadDir(dir) {
   return out;
 }
 function discover(dir) {
-  if (!existsSync21(dir))
+  if (!existsSync23(dir))
     return [];
   const out = [];
   let entries;
   try {
-    entries = readdirSync5(dir);
+    entries = readdirSync6(dir);
   } catch {
     return out;
   }
   for (const name of entries) {
-    const extDir = join18(dir, name);
-    const pkgFile = join18(extDir, "package.json");
+    const extDir = join20(dir, name);
+    const pkgFile = join20(extDir, "package.json");
     try {
-      if (!statSync6(extDir).isDirectory() || !existsSync21(pkgFile))
+      if (!statSync6(extDir).isDirectory() || !existsSync23(pkgFile))
         continue;
-      const pkg = JSON.parse(readFileSync13(pkgFile, "utf8"));
+      const pkg = JSON.parse(readFileSync14(pkgFile, "utf8"));
       const themes = pkg.contributes?.themes;
       if (!Array.isArray(themes))
         continue;
       const ext = `${pkg.publisher ?? "local"}.${pkg.name ?? name}`;
       let nls = {};
-      const nlsFile = join18(extDir, "package.nls.json");
-      if (existsSync21(nlsFile)) {
+      const nlsFile = join20(extDir, "package.nls.json");
+      if (existsSync23(nlsFile)) {
         try {
-          nls = JSON.parse(readFileSync13(nlsFile, "utf8"));
+          nls = JSON.parse(readFileSync14(nlsFile, "utf8"));
         } catch {}
       }
       for (const c of themes) {
@@ -24525,6 +25077,21 @@ class UpdateService {
     this.wanted = true;
     await this.proceed();
   }
+  async checkNow() {
+    if (this.d.managed)
+      throw new UserError("Updates are turned off for this machine (TOYON_UPDATES=off)");
+    if (this.d.method === "none") {
+      throw new UserError(`Toyon ${this.d.running} runs from a checkout, which does not update itself`);
+    }
+    await this.check();
+    if (this.unreachable)
+      throw new UserError(`Could not reach ${this.unreachable}`);
+    if (this.target() === null)
+      throw new UserError(`Toyon ${this.d.running} is the newest version`);
+  }
+  install() {
+    return this.d.method;
+  }
   get() {
     const restarting = this.d.restarter.waitingOn() ?? (this.wanted && !this.installing ? this.d.restarter.working() : null);
     if (this.installed === null && this.latest === null && !this.installing && this.failed === null && restarting === null) {
@@ -24745,14 +25312,22 @@ var DIFF_CHARS = 2000;
 class LandingService {
   d;
   judging = new Map;
+  busy = new Set;
   constructor(d) {
     this.d = d;
     d.hub.on("turnSettled", (id, turn) => fireAndForget(id, this.settle(id, turn), "landing verdict"));
     d.hub.on("agentStatus", (id, status) => {
+      this.note(id, status);
       if (status === "working")
         this.clear(id);
     });
   }
+  note(worktreeId, status) {
+    if (status === "working" || status === "waiting")
+      this.busy.add(worktreeId);
+    else
+      this.busy.delete(worktreeId);
+  }
   clear(worktreeId) {
     this.judging.delete(worktreeId);
     this.d.worktrees.setLanding(worktreeId, undefined);
@@ -24763,28 +25338,91 @@ class LandingService {
       return;
     if (turn.end !== "done")
       return this.clear(worktreeId);
+    if (!await this.hasWork(wt)) {
+      this.clear(worktreeId);
+      return this.recapAnswer(wt, turn);
+    }
+    await this.run(wt, { at: turn.at, ask: true, quiet: false });
+  }
+  async recapAnswer(wt, turn) {
+    if (!this.d.recap)
+      return;
+    const worktreeId = wt.id;
+    const entries = this.d.transcript(worktreeId);
+    const turns = turnsSince(entries, 0);
+    if (!turns.at(-1)?.reply.trim())
+      return;
+    this.judging.set(worktreeId, turn.at);
+    const started = Date.now();
+    let text = null;
+    try {
+      text = await this.d.recap(wt, answerPrompt({ title: wt.title, firstAsk: firstAskOf(entries), turns }));
+    } catch (e) {
+      log.warn(worktreeId, "answer recap failed", e);
+    }
+    if (this.judging.get(worktreeId) !== turn.at)
+      return;
+    this.judging.delete(worktreeId);
+    const record = this.d.state.worktree(worktreeId)?.lastTurn;
+    if (!text || !record || record.at !== turn.at)
+      return;
+    record.recap = { at: Date.now(), text };
+    log.info(worktreeId, `answer recap, ${Date.now() - started}ms`);
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
+  }
+  async judge(worktreeId) {
+    const wt = this.d.state.requireWorktree(worktreeId);
+    if (!canLand(wt))
+      throw new UserError("nothing to land from here");
+    if (this.busy.has(worktreeId))
+      throw new UserError("wait for the turn to end");
+    if (!await this.hasWork(wt))
+      throw new UserError("nothing to check: no changes here");
+    fireAndForget(worktreeId, this.run(wt, { at: Date.now(), ask: true, quiet: false }), "landing verdict by hand");
+  }
+  recheck(worktreeId) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt?.landing || !canLand(wt) || this.busy.has(worktreeId))
+      return;
+    fireAndForget(worktreeId, this.run(wt, { at: Date.now(), ask: false, quiet: true }), "landing recheck");
+  }
+  async hasWork(wt) {
     const repo = this.d.state.requireRepo(wt.repoId);
     const files = await statusFiles(wt.path);
+    if (files.length > 0)
+      return true;
     const { ahead } = await aheadBehind(wt.path, repo.defaultBranch);
-    if (files.length === 0 && ahead === 0)
+    return ahead > 0;
+  }
+  async run(wt, opts) {
+    const worktreeId = wt.id;
+    const repo = this.d.state.requireRepo(wt.repoId);
+    if (!await this.hasWork(wt))
       return this.clear(worktreeId);
-    this.judging.set(worktreeId, turn.at);
+    const held = opts.ask ? undefined : wt.landing;
+    const kept = {
+      ...held?.why ? { why: held.why } : {},
+      ...held?.subject ? { subject: held.subject } : {},
+      ...held?.body ? { body: held.body } : {}
+    };
+    this.judging.set(worktreeId, opts.at);
     const started = Date.now();
-    this.d.worktrees.setLanding(worktreeId, { at: turn.at, check: "pending", ready: false, fingerprint: "" });
-    const live = () => this.judging.get(worktreeId) === turn.at && this.d.state.worktree(worktreeId)?.lastTurn?.at === turn.at;
+    this.d.worktrees.setLanding(worktreeId, { at: opts.at, check: "pending", ready: false, fingerprint: "", ...kept });
+    const live = () => this.judging.get(worktreeId) === opts.at && !!this.d.state.worktree(worktreeId);
     let check = "none";
     let checkTail;
     const command = repo.config.check?.trim();
     if (command) {
-      const r = await this.d.check(worktreeId, command);
+      const r = await this.d.check(worktreeId, command, { quiet: opts.quiet });
       if (!live())
         return;
       check = r.exit === 0 ? "pass" : "fail";
       if (check === "fail")
-        checkTail = tail2(r.text) || `exit ${r.exit}`;
+        checkTail = tail(r.text) || `exit ${r.exit}`;
     }
     let verdict = null;
-    if (check !== "fail" && this.d.judge) {
+    if (opts.ask && check !== "fail" && this.d.judge) {
       const entries = this.d.transcript(worktreeId);
       const prompt = landPrompt({
         title: wt.title,
@@ -24802,10 +25440,11 @@ class LandingService {
         return;
     }
     const landing = {
-      at: turn.at,
+      at: opts.at,
       check,
       ...checkTail ? { checkTail } : {},
       ready: check !== "fail",
+      ...kept,
       ...verdict && !verdict.ready && verdict.why ? { why: verdict.why } : {},
       ...verdict?.subject ? { subject: verdict.subject } : {},
       ...verdict?.body ? { body: verdict.body } : {},
@@ -24814,11 +25453,14 @@ class LandingService {
     if (!live())
       return;
     this.judging.delete(worktreeId);
-    log.info(worktreeId, `landing: check ${check}${landing.why ? ", doubted" : ""}, ${Date.now() - started}ms`);
+    const record = this.d.state.worktree(worktreeId)?.lastTurn;
+    if (record && verdict?.recap)
+      record.recap = { at: Date.now(), text: verdict.recap };
+    log.info(worktreeId, `landing: check ${check}${landing.why ? ", doubted" : ""}${opts.ask ? "" : ", check only"}, ${Date.now() - started}ms`);
     this.d.worktrees.setLanding(worktreeId, landing);
   }
 }
-function tail2(text) {
+function tail(text) {
   const t = text.replace(/\s+$/, "");
   return t.length > TAIL_CHARS ? t.slice(-TAIL_CHARS) : t;
 }
@@ -25028,11 +25670,8 @@ function discoveredId(path) {
 }
 function knownPaths(known) {
   const paths = new Set;
-  for (const wt of known) {
+  for (const wt of known)
     paths.add(canonical(wt.path));
-    if (wt.linkPath)
-      paths.add(canonical(wt.linkPath));
-  }
   return paths;
 }
 function subtractKnown(repoId, listed, known) {
@@ -25100,7 +25739,7 @@ class RefSearch {
   rowIdForPath = (path) => {
     const want = canonical(path);
     for (const wt of this.d.state.worktrees) {
-      if (canonical(wt.path) === want || wt.linkPath && canonical(wt.linkPath) === want)
+      if (canonical(wt.path) === want)
         return wt.id;
     }
     return discoveredId(path);
@@ -25210,8 +25849,8 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { existsSync as existsSync23, lstatSync, readlinkSync, rmSync as rmSync5, symlinkSync, unlinkSync } from "fs";
-import { basename as basename6, dirname as dirname8, join as join21 } from "path";
+import { cpSync, existsSync as existsSync26, readFileSync as readFileSync16, rmSync as rmSync5 } from "fs";
+import { dirname as dirname9, join as join23 } from "path";
 
 // ../daemon/src/git/archive.ts
 import { rmSync as rmSync3 } from "fs";
@@ -25220,12 +25859,16 @@ async function keepState(repoPath, wtPath, ref, indexFile) {
   const head = await git(wtPath, "rev-parse", "--verify", "HEAD");
   if (!head.ok)
     return null;
-  const status = await git(wtPath, "status", "--porcelain");
-  const dirty = !status.ok || status.out !== "";
+  const status = await gitRaw(wtPath, "status", "--porcelain", "-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;
   if (!(await git(repoPath, "update-ref", ref, snapshot ?? head.out)).ok)
     return null;
-  return { head: head.out, ...snapshot ? { snapshot } : dirty ? { lost: true } : {} };
+  return {
+    head: head.out,
+    ...snapshot ? { snapshot, ...files ? { dirty: files } : {} } : dirty ? { lost: true } : {}
+  };
 }
 async function snapshotCommit(wtPath, head, indexFile) {
   const env = { GIT_INDEX_FILE: indexFile };
@@ -25277,6 +25920,32 @@ async function landingMark(worktreePath, defaultBr) {
     return null;
   return { base: base.out, tip: tip.out };
 }
+async function handLanding(worktreePath, branch, defaultBr, since) {
+  const log = await git(worktreePath, "reflog", "show", "--format=%H %gs", branch);
+  if (!log.ok || !log.out)
+    return null;
+  let own = 0;
+  for (const line of log.out.split(`
+`)) {
+    const subject = line.slice(line.indexOf(" ") + 1);
+    if (/^(reset|branch):/.test(subject))
+      break;
+    if (/^(commit|cherry-pick)\b/.test(subject) && !subject.startsWith("commit (amend)"))
+      own++;
+  }
+  if (own === 0)
+    return null;
+  const [tip, walked, onMain, fromSince] = await Promise.all([
+    git(worktreePath, "rev-parse", "HEAD"),
+    git(worktreePath, "rev-parse", `HEAD~${own}`),
+    git(worktreePath, "merge-base", "--is-ancestor", "HEAD", defaultBr),
+    since ? git(worktreePath, "merge-base", "--is-ancestor", since, "HEAD") : null
+  ]);
+  if (!tip.ok || !onMain.ok || !walked.ok)
+    return null;
+  const base = fromSince?.ok && since ? since : walked.out;
+  return base === tip.out ? null : { base, tip: tip.out };
+}
 async function dropLandRefs(repoPath, worktreeId) {
   const r = await git(repoPath, "for-each-ref", "--format=%(refname)", `refs/toyon/lands/${worktreeId}/`);
   if (!r.ok || !r.out)
@@ -25292,8 +25961,11 @@ async function commitWorktree(worktreePath, message) {
     return { ok: false, message: "nothing to commit" };
   await git(worktreePath, "add", "-A");
   const c = await git(worktreePath, "commit", "-m", message);
-  if (!c.ok)
-    return { ok: false, message: `commit failed: ${c.err.slice(0, 200)}` };
+  if (!c.ok) {
+    const output = [c.out, c.err].filter(Boolean).join(`
+`);
+    return { ok: false, message: `commit failed: ${c.err.slice(0, 200)}`, output, exit: c.exit };
+  }
   return { ok: true, message: `committed: ${message}` };
 }
 async function requireClean(worktreePath) {
@@ -25399,21 +26071,37 @@ async function fastForwardMain(repoPath, defaultBr) {
   const f = await run(GIT, ["fetch", "--quiet"], repoPath, NO_PROMPT);
   if (!f.ok)
     return { ok: false, message: `fetch failed: ${f.err.slice(0, 200)}` };
+  return fastForwardFetched(repoPath, defaultBr);
+}
+async function fastForwardFetched(repoPath, defaultBr) {
+  const current = await git(repoPath, "branch", "--show-current");
+  if (current.out !== defaultBr) {
+    return { ok: false, message: `main checkout is on '${current.out}', not ${defaultBr}; switch it first` };
+  }
   const behind = await behindUpstream(repoPath);
-  if (behind === null)
-    return { ok: false, message: `${defaultBr} has no upstream to pull from` };
+  if (behind === null) {
+    return { ok: false, stale: "no-upstream", message: `${defaultBr} has no upstream to pull from` };
+  }
   if (behind === 0)
-    return { ok: true, message: "already up to date with origin" };
+    return { ok: true, moved: false, message: "already up to date with origin" };
+  if ((await statusFiles(repoPath)).length > 0) {
+    return {
+      ok: false,
+      stale: "dirty",
+      message: `${defaultBr} has uncommitted changes: commit or stash them there first`
+    };
+  }
   const m = await git(repoPath, "merge", "--ff-only", "@{upstream}");
   if (!m.ok) {
     const clobber = /overwritten by merge|would be overwritten/.test(`${m.out}
 ${m.err}`);
-    return {
+    return clobber ? {
       ok: false,
-      message: clobber ? `${defaultBr} here has edits the pull would overwrite; commit or stash them first` : `${defaultBr} has diverged from origin; reconcile it in a terminal`
-    };
+      stale: "dirty",
+      message: `${defaultBr} here has edits the pull would overwrite; commit or stash them first`
+    } : { ok: false, stale: "diverged", message: `${defaultBr} has diverged from origin; reconcile it in a terminal` };
   }
-  return { ok: true, message: `pulled ${behind} commit(s) from origin` };
+  return { ok: true, moved: true, message: `pulled ${behind} commit(s) from origin` };
 }
 async function pushMain(repoPath, defaultBr) {
   const p = await run(GIT, ["push", "origin", defaultBr], repoPath, NO_PROMPT);
@@ -25435,6 +26123,12 @@ async function mergeFailure(cwd, m, conflictMessage) {
   }
   return { ok: false, message: `merge failed: ${said.slice(0, 300)}` };
 }
+async function pushBranch(worktreePath, branch) {
+  const push = await run(GIT, ["push", "-u", "--force-with-lease", "origin", branch], worktreePath, NO_PROMPT);
+  if (!push.ok)
+    return { ok: false, message: `push failed: ${push.err.slice(0, 300)}` };
+  return { ok: true, message: `pushed ${branch}` };
+}
 async function openPr(o) {
   const cErr = await requireClean(o.worktreePath);
   if (cErr)
@@ -25445,9 +26139,9 @@ async function openPr(o) {
   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 run(GIT, ["push", "-u", "--force-with-lease", "origin", o.branch], o.worktreePath, NO_PROMPT);
+  const push = await pushBranch(o.worktreePath, o.branch);
   if (!push.ok)
-    return { ok: false, message: `push failed: ${push.err.slice(0, 300)}` };
+    return push;
   const titled = o.subject ? ["--title", o.subject, "--body", o.body ?? ""] : ["--fill"];
   const created = await gh(["pr", "create", "--head", o.branch, "--base", o.defaultBr, ...titled], o.worktreePath);
   let url = null;
@@ -25497,20 +26191,20 @@ function compareUrl(remoteUrl, base, branch) {
 }
 
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync6, readdirSync as readdirSync6, readFileSync as readFileSync14, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync7, readdirSync as readdirSync7, readFileSync as readFileSync15, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename6, dirname as dirname8, join as join21 } from "path";
 class WorktreeArchive {
   dir;
   records = new Map;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync6(dir, { recursive: true });
-    for (const id of readdirSync6(dir)) {
+    mkdirSync7(dir, { recursive: true });
+    for (const id of readdirSync7(dir)) {
       const file = this.filesOf(id).record;
-      if (!existsSync22(file))
+      if (!existsSync24(file))
         continue;
       try {
-        this.records.set(id, JSON.parse(readFileSync14(file, "utf8")));
+        this.records.set(id, JSON.parse(readFileSync15(file, "utf8")));
       } catch (e) {
         log.warn("archive", `skipped an unreadable record: ${file}`, e);
       }
@@ -25521,11 +26215,13 @@ class WorktreeArchive {
   }
   put(rec, from) {
     const at = this.filesOf(rec.worktree.id);
-    mkdirSync6(at.dir, { recursive: true });
+    mkdirSync7(at.dir, { recursive: true });
     move(from.transcript, at.transcript);
     move(from.attachments, at.attachments);
-    writeFileSync8(at.record, JSON.stringify(rec, null, 2));
+    move(from.plans, at.plans);
+    writeFileSync9(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))
@@ -25533,6 +26229,7 @@ class WorktreeArchive {
     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) {
@@ -25542,25 +26239,39 @@ class WorktreeArchive {
     this.records.delete(id);
   }
   list(repo) {
-    return [...this.records.values()].filter((r) => r.worktree.repoId === repo.id || r.repoPath === repo.path).sort((a, b) => b.archivedAt - a.archivedAt).map((r) => summarize(r, repo.id));
+    return [...this.records.values()].filter((r) => r.worktree.repoId === repo.id || r.repoPath === repo.path).sort((a, b) => b.archivedAt - a.archivedAt).map((r) => summarize(r, repo.id, this.filesOf(r.worktree.id).transcript));
   }
   chatFiles(id) {
     if (!this.records.has(id))
       return;
     const at = this.filesOf(id);
-    return { transcript: at.transcript, attachments: at.attachments };
+    return { transcript: at.transcript, attachments: at.attachments, plans: at.plans };
+  }
+  planFile(id, rel) {
+    if (!this.records.has(id) || !isPlanPath(rel))
+      return null;
+    const file = join21(this.filesOf(id).plans, basename6(rel));
+    if (!existsSync24(file))
+      return null;
+    try {
+      return readFileSync15(file, "utf8");
+    } catch (e) {
+      log.warn(id, `could not read its archived plan ${rel}`, e);
+      return null;
+    }
   }
   filesOf(id) {
-    const dir = join19(this.dir, id);
+    const dir = join21(this.dir, id);
     return {
       dir,
-      record: join19(dir, "record.json"),
-      transcript: join19(dir, "transcript.jsonl"),
-      attachments: join19(dir, "attachments")
+      record: join21(dir, "record.json"),
+      transcript: join21(dir, "transcript.jsonl"),
+      attachments: join21(dir, "attachments"),
+      plans: join21(dir, "plans")
     };
   }
 }
-function summarize(r, repoId) {
+function summarize(r, repoId, transcript) {
   return {
     id: r.worktree.id,
     repoId,
@@ -25571,16 +26282,18 @@ function summarize(r, repoId) {
     archivedAt: r.archivedAt,
     ...r.prompt ? { prompt: r.prompt } : {},
     restorable: !!r.kept,
-    ...r.kept?.snapshot ? { uncommitted: true } : {},
+    transcript,
+    ...r.sessionId ? { sessionId: r.sessionId } : {},
+    ...r.kept?.snapshot ? { uncommitted: true, ...r.kept.dirty ? { dirty: r.kept.dirty } : {} } : {},
     ...r.worktree.landed ? { landed: true } : {},
     ...r.cost !== undefined ? { cost: r.cost } : {},
     ...r.auto ? { auto: r.auto } : {}
   };
 }
 function lastUsage(transcript) {
-  if (!existsSync22(transcript))
+  if (!existsSync24(transcript))
     return null;
-  const lines = readFileSync14(transcript, "utf8").split(`
+  const lines = readFileSync15(transcript, "utf8").split(`
 `);
   for (let i = lines.length - 1;i >= 0; i--) {
     if (!lines[i]?.includes('"usage"'))
@@ -25594,9 +26307,9 @@ function lastUsage(transcript) {
   return null;
 }
 function firstPrompt(transcript) {
-  if (!existsSync22(transcript))
+  if (!existsSync24(transcript))
     return;
-  for (const line of readFileSync14(transcript, "utf8").split(`
+  for (const line of readFileSync15(transcript, "utf8").split(`
 `)) {
     if (!line.includes('"user-message"'))
       continue;
@@ -25609,8 +26322,9 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync22(from))
+  if (!existsSync24(from))
     return;
+  mkdirSync7(dirname8(to), { recursive: true });
   rmSync4(to, { recursive: true, force: true });
   renameSync4(from, to);
 }
@@ -25673,16 +26387,31 @@ class ArchivedGit {
 }
 
 // ../daemon/src/worktrees/spare.ts
-import { join as join20 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { basename as basename7, join as join22 } from "path";
 class SparePool {
   d;
-  spares = new Map;
+  inflight = new Map;
+  refreshing = new Map;
   constructor(d) {
     this.d = d;
   }
+  spareOf(repoId) {
+    return this.d.state.worktrees.find((w) => w.repoId === repoId && w.kind === "spare");
+  }
   current(repoId) {
-    const entry = this.spares.get(repoId);
-    return entry?.worktreeId ? { worktreeId: entry.worktreeId, ready: entry.ready } : null;
+    const wt = this.spareOf(repoId);
+    return wt ? { worktreeId: wt.id, ready: wt.phase === "ready" } : null;
+  }
+  typed(boxId, text) {
+    if (!text.trim())
+      return;
+    const wt = this.d.state.worktree(boxId);
+    if (wt?.kind !== "spare" || !existsSync25(wt.path))
+      return;
+    const agent = this.d.runtime.ensureAgent(wt).agent;
+    if (agent.runningAgent === null)
+      fireAndForget(wt.id, agent.warm(), "warm on the first keystroke");
   }
   adopt(repoId) {
     const persisted = this.d.state.worktrees.filter((w) => w.repoId === repoId && w.kind === "spare");
@@ -25691,76 +26420,125 @@ class SparePool {
     const spare = persisted[0];
     if (!spare)
       return;
-    this.spares.set(repoId, {
-      worktreeId: spare.id,
-      lockHash: lockfileHash(spare.path),
-      refreshing: null,
-      ready: true
-    });
+    spare.phase ??= "ready";
+    spare.lockfile ??= lockfileHash(spare.path);
   }
   warm(repoId) {
-    if (this.spares.has(repoId))
+    const wt = this.spareOf(repoId);
+    if (wt?.phase === "ready")
       fireAndForget(repoId, this.revive(repoId), "spare refresh");
     else
       fireAndForget(repoId, this.ensure(repoId), "spare warm-up");
   }
   async revive(repoId) {
     await this.refresh(repoId);
-    const entry = this.spares.get(repoId);
-    const wt = entry?.ready ? this.d.state.worktree(entry.worktreeId) : undefined;
-    if (wt?.kind !== "spare" || this.d.runtime.get(wt.id)?.procs)
+    const wt = this.spareOf(repoId);
+    if (wt?.phase !== "ready" || this.d.runtime.get(wt.id)?.procs)
       return;
     await this.d.runtime.start(wt, this.d.state.requireRepo(repoId));
   }
-  async ensure(repoId) {
-    if (this.spares.has(repoId))
-      return;
+  ensure(repoId) {
+    const running = this.inflight.get(repoId);
+    if (running)
+      return running.done;
+    const have = this.spareOf(repoId);
+    if (have?.phase === "ready")
+      return Promise.resolve();
     const repo = this.d.state.requireRepo(repoId);
+    if (have)
+      return this.warmUp(have, repo, {});
     if (repo.needsSetup)
-      return;
-    const entry = { worktreeId: "", lockHash: "", refreshing: null, ready: false };
-    this.spares.set(repoId, entry);
-    try {
-      const slug = `wt-${shortId().slice(0, 4)}`;
-      const wtPath = join20(this.d.paths.worktreesDir, repo.name, slug);
-      await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--detach", wtPath, repo.defaultBranch));
-      const wt = {
-        id: shortId(),
-        repoId,
-        path: wtPath,
-        branch: repo.defaultBranch,
-        kind: "spare",
-        proxyPort: await allocateProxyPort(),
-        title: slug,
-        createdAt: Date.now()
-      };
-      entry.worktreeId = wt.id;
-      this.d.state.addWorktree(wt);
-      await this.d.setupAndStart(wt, repo);
-      entry.lockHash = lockfileHash(wt.path);
-      entry.ready = true;
-      this.d.hub.emit("worktreesChanged");
-    } catch (e) {
-      log.warn(repoId, "spare warm-up failed; rolling back", e);
-      this.spares.delete(repoId);
-      if (entry.worktreeId && this.d.state.worktree(entry.worktreeId)) {
-        await this.d.discard(entry.worktreeId).catch((re) => log.warn(repoId, "spare rollback failed", re));
+      return Promise.resolve();
+    return this.record(repoId, repo).then((wt) => this.warmUp(wt, repo, {}));
+  }
+  async record(repoId, repo) {
+    const { id, dir } = freeSlot(join22(this.d.paths.worktreesDir, repo.name));
+    const wt = {
+      id,
+      repoId,
+      path: join22(this.d.paths.worktreesDir, repo.name, dir),
+      branch: repo.defaultBranch,
+      kind: "spare",
+      phase: "reserved",
+      proxyPort: await allocateProxyPort(),
+      title: dir,
+      createdAt: Date.now()
+    };
+    this.d.state.addWorktree(wt);
+    return wt;
+  }
+  warmUp(wt, repo, { after }) {
+    const repoId = repo.id;
+    let cut = () => {};
+    const added = (async () => {
+      if (existsSync25(wt.path))
+        return;
+      await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--detach", wt.path, repo.defaultBranch));
+    })();
+    const done = (async () => {
+      try {
+        await added;
+        if (after) {
+          await Promise.race([
+            this.d.runtime.awaitPreview(after, STAGGER_MS),
+            new Promise((r) => {
+              cut = r;
+            })
+          ]);
+        }
+        if (!this.d.state.worktree(wt.id))
+          return;
+        if (wt.kind === "spare") {
+          wt.phase = "warming";
+          this.d.state.save();
+          this.d.hub.emit("worktreesChanged");
+          await withRepoLock(repo.path, () => git(wt.path, "reset", "--hard", repo.defaultBranch));
+        }
+        await this.d.setupAndStart(wt, repo);
+        if (wt.kind !== "spare")
+          return;
+        wt.lockfile = lockfileHash(wt.path);
+        wt.phase = "ready";
+        this.d.state.save();
+        this.d.ready?.(repoId);
+        this.d.hub.emit("worktreesChanged");
+      } catch (e) {
+        await this.rollBack(wt, e);
+      } finally {
+        if (this.inflight.get(repoId)?.added === added)
+          this.inflight.delete(repoId);
       }
+    })();
+    this.inflight.set(repoId, { added, done, cut: () => cut() });
+    return done;
+  }
+  async rollBack(wt, e) {
+    if (wt.kind !== "spare") {
+      log.warn(wt.id, "setup failed after the spare was claimed", e);
+      return;
+    }
+    log.warn(wt.repoId, "spare warm-up failed; rolling back", e);
+    this.d.carryDraft?.(wt.id, wt.repoId);
+    if (existsSync25(wt.path)) {
+      await this.d.discard(wt.id).catch((re) => log.warn(wt.repoId, "spare rollback failed", re));
+      return;
     }
+    this.d.state.removeWorktree(wt.id);
+    releasePort(wt.proxyPort);
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
   }
   async refresh(repoId) {
-    const entry = this.spares.get(repoId);
-    if (!entry?.ready || entry.refreshing)
+    const wt = this.spareOf(repoId);
+    if (wt?.phase !== "ready" || this.refreshing.has(repoId))
       return;
     const repo = this.d.state.requireRepo(repoId);
-    const wt = this.d.state.worktree(entry.worktreeId);
-    if (wt?.kind !== "spare")
-      return;
-    entry.refreshing = (async () => {
+    const run = (async () => {
       await withRepoLock(repo.path, () => git(wt.path, "reset", "--hard", repo.defaultBranch));
       const h = lockfileHash(wt.path);
-      if (h !== entry.lockHash) {
-        entry.lockHash = h;
+      if (h !== wt.lockfile) {
+        wt.lockfile = h;
+        this.d.state.save();
         for (const cmd of repo.config.setup ?? []) {
           const tail = [];
           const code = await runSetup(cmd, wt.path, (line) => {
@@ -25774,70 +26552,161 @@ class SparePool {
         }
       }
     })().finally(() => {
-      entry.refreshing = null;
+      this.refreshing.delete(repoId);
     });
-    await entry.refreshing;
+    this.refreshing.set(repoId, run);
+    await run;
   }
-  async claim(repoId, branch, slug) {
-    const entry = this.spares.get(repoId);
-    if (!entry?.ready)
+  async claim(repoId, title, worktreeId) {
+    const wt = this.spareOf(repoId);
+    if (!wt)
       return null;
-    this.spares.delete(repoId);
-    if (entry.refreshing)
-      await entry.refreshing;
-    const wt = this.d.state.worktree(entry.worktreeId);
-    if (wt?.kind !== "spare")
+    if (worktreeId && wt.id !== worktreeId)
       return null;
-    const repo = this.d.state.requireRepo(repoId);
-    try {
-      await withRepoLock(repo.path, () => gitOrThrow(wt.path, "switch", "-c", branch));
-    } catch (e) {
-      this.spares.set(repoId, { ...entry, ready: true });
-      throw e;
+    const wasReady = wt.phase === "ready";
+    if (!wasReady) {
+      if (!worktreeId)
+        return null;
+      const running = this.inflight.get(repoId);
+      await running?.added.catch(() => {});
+      running?.cut();
+      if (wt.kind !== "spare" || !existsSync25(wt.path))
+        return null;
     }
+    await this.refreshing.get(repoId);
+    const repo = this.d.state.requireRepo(repoId);
+    const branch = `toyon/${basename7(wt.path)}`;
+    await withRepoLock(repo.path, () => gitOrThrow(wt.path, "switch", "-c", branch));
     wt.kind = "worktree";
+    delete wt.phase;
+    delete wt.lockfile;
     wt.branch = branch;
-    wt.title = slug;
+    wt.title = title;
+    wt.unnamed = true;
     wt.createdAt = Date.now();
+    if (wasReady)
+      fireAndForget(wt.id, this.d.runtime.wake(wt.id), "wake on claim");
+    const next = repo.needsSetup ? null : await this.record(repoId, repo);
     this.d.state.save();
-    fireAndForget(wt.id, this.d.runtime.wake(wt.id), "wake on claim");
-    fireAndForget(repoId, this.ensure(repoId), "spare warm-up");
+    if (next)
+      fireAndForget(repoId, this.warmUp(next, repo, { after: wt.id }), "spare reserve");
     return wt;
   }
 }
 
+// ../daemon/src/worktrees/trunk.ts
+var FETCH_EVERY_MS = 5 * 60000;
+var OPEN_FETCH_MIN_MS = 60000;
+function mainOf(state, repoId) {
+  return state.worktrees.find((w) => w.repoId === repoId && w.kind === "main");
+}
+
+class Trunk {
+  d;
+  lastFetch = new Map;
+  stale = new Map;
+  constructor(d) {
+    this.d = d;
+  }
+  async behind(mainId, path) {
+    const behind = await behindUpstream(path);
+    if (behind === null)
+      return {};
+    const last = this.lastFetch.get(path) ?? 0;
+    if (Date.now() - last > FETCH_EVERY_MS) {
+      this.lastFetch.set(path, Date.now());
+      fireAndForget("fetch", run(GIT, ["fetch", "--quiet"], path, NO_PROMPT).then(async (r) => {
+        if (!r.ok) {
+          log.warn("fetch", `could not fetch ${path}: ${r.err.slice(0, 200)}`);
+          return;
+        }
+        this.d.invalidateCounts();
+        this.d.hub.emit("worktreesChanged");
+        if (await behindUpstream(path) ?? 0)
+          await this.follow(mainId);
+      }));
+    }
+    return { behind };
+  }
+  async sync(repoId) {
+    const repo = this.d.state.repo(repoId);
+    const main = mainOf(this.d.state, repoId);
+    if (!repo || !main)
+      return;
+    const last = this.lastFetch.get(repo.path) ?? 0;
+    if (Date.now() - last < OPEN_FETCH_MIN_MS)
+      return;
+    this.lastFetch.set(repo.path, Date.now());
+    const f = await run(GIT, ["fetch", "--quiet"], repo.path, NO_PROMPT);
+    if (!f.ok) {
+      log.warn("fetch", `could not fetch ${repo.path}: ${f.err.slice(0, 200)}`);
+      return;
+    }
+    this.d.invalidateCounts();
+    await this.follow(main.id);
+  }
+  async follow(mainId) {
+    const main = this.d.state.worktree(mainId);
+    const repo = main && this.d.state.repo(main.repoId);
+    if (!main || !repo)
+      return;
+    const ff = await withRepoLock(repo.path, () => fastForwardFetched(repo.path, repo.defaultBranch));
+    const was = this.stale.get(repo.id);
+    if (ff.stale)
+      this.stale.set(repo.id, ff.stale);
+    else
+      this.stale.delete(repo.id);
+    if (ff.moved) {
+      this.d.invalidateCounts();
+      this.d.hub.emit("worktreesChanged");
+    } else if (was !== ff.stale)
+      this.d.hub.emit("worktreesChanged");
+  }
+  async all(opts = {}) {
+    const quick = opts.quick ? { missed: false } : null;
+    const out = {};
+    await Promise.all(this.d.state.repos.map(async (repo) => {
+      const main = mainOf(this.d.state, repo.id);
+      if (!main)
+        return;
+      const { behind, dirty } = await this.d.counts(main, repo.defaultBranch, quick);
+      const stale = this.stale.get(repo.id);
+      out[repo.id] = {
+        id: main.id,
+        ...behind !== undefined ? { behind } : {},
+        dirty: dirty ?? 0,
+        empty: main.empty === true,
+        ...stale ? { stale } : {}
+      };
+    }));
+    if (quick?.missed)
+      setTimeout(() => this.d.hub.emit("worktreesChanged"), 0);
+    return out;
+  }
+}
+
 // ../daemon/src/worktrees/turns.ts
 var TURN_HOLD = "turn";
-var RECAP_DELAY_MS = Number(process.env.TOYON_RECAP_DELAY_MS) || 2 * 60000;
 
 class TurnService {
   d;
   lastStatus = new Map;
   stoppedByHand = new Set;
-  timers = new Map;
-  summarized = new Map;
   constructor(d) {
     this.d = d;
     this.boot();
     d.hub.on("agentStatus", (worktreeId, status) => this.onStatus(worktreeId, status));
   }
   boot() {
-    const now = Date.now();
     let changed = false;
     for (const wt of this.d.state.worktrees) {
       const turn = wt.lastTurn;
-      if (!turn)
+      if (turn?.end !== "asking")
         continue;
-      if (turn.end === "asking") {
-        const { ask: _expired, ...facts } = turn.facts;
-        turn.end = "stopped";
-        turn.facts = facts;
-        changed = true;
-      }
-      if (!turn.recap && (wt.seenAt ?? 0) < turn.at) {
-        turn.recap = { at: now };
-        changed = true;
-      }
+      const { ask: _expired, ...facts } = turn.facts;
+      turn.end = "stopped";
+      turn.facts = facts;
+      changed = true;
     }
     if (changed)
       this.d.state.save();
@@ -25845,10 +26714,8 @@ class TurnService {
   onStatus(worktreeId, status) {
     const prev = this.lastStatus.get(worktreeId) ?? "idle";
     this.lastStatus.set(worktreeId, status);
-    if (status === "working") {
-      this.disarm(worktreeId);
+    if (status === "working")
       this.d.hold?.(worktreeId, TURN_HOLD);
-    }
     const edge = stopOf(prev, status);
     if (!edge)
       return;
@@ -25863,64 +26730,13 @@ class TurnService {
     wt.lastTurn = { at, end, facts: factsOf(turns, end, end === "asking" ? openAskOf(entries) : undefined) };
     if (this.stoppedByHand.delete(worktreeId) && end === "stopped")
       wt.seenAt = at;
-    this.disarm(worktreeId);
-    if ((wt.seenAt ?? 0) < at)
-      this.arm(worktreeId, at);
     this.d.state.save();
     this.d.hub.emit("turnSettled", worktreeId, wt.lastTurn);
   }
-  arm(worktreeId, at) {
-    const t = setTimeout(() => this.due(worktreeId, at), this.d.delayMs ?? RECAP_DELAY_MS);
-    t.unref?.();
-    this.timers.set(worktreeId, t);
-  }
-  disarm(worktreeId) {
-    const t = this.timers.get(worktreeId);
-    if (!t)
-      return;
-    clearTimeout(t);
-    this.timers.delete(worktreeId);
-  }
-  due(worktreeId, at) {
-    this.timers.delete(worktreeId);
-    const wt = this.d.state.worktree(worktreeId);
-    const turn = wt?.lastTurn;
-    if (!wt || !turn || turn.at !== at || (wt.seenAt ?? 0) >= at)
-      return;
-    turn.recap = { at: Date.now() };
-    this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
-    const seenAt = wt.seenAt ?? 0;
-    const summarize = this.d.summarize;
-    if (!summarize || turn.facts.auth)
-      return;
-    if (this.summarized.get(worktreeId) === seenAt)
-      return;
-    this.summarized.set(worktreeId, seenAt);
-    const entries = this.d.transcript(worktreeId);
-    const prompt = recapPrompt({
-      title: wt.title,
-      firstAsk: firstAskOf(entries),
-      turns: turnsSince(entries, seenAt),
-      end: turn.end,
-      facts: turn.facts
-    });
-    fireAndForget(worktreeId, this.write(worktreeId, at, summarize(wt, prompt)), "recap summary");
-  }
-  async write(worktreeId, at, sentence) {
-    const text = await sentence;
-    const turn = this.d.state.worktree(worktreeId)?.lastTurn;
-    if (!text || turn?.at !== at || !turn.recap)
-      return;
-    turn.recap.text = text;
-    this.d.state.save();
-    this.d.hub.emit("worktreesChanged");
-  }
   stoppedByPerson(worktreeId) {
     this.stoppedByHand.add(worktreeId);
   }
   markSeen(worktreeId) {
-    this.disarm(worktreeId);
     const wt = this.d.state.worktree(worktreeId);
     if (!wt)
       return;
@@ -25953,6 +26769,7 @@ function stopOf(prev, next) {
 
 // ../daemon/src/worktrees/service.ts
 var LOCAL_CONFIG_FILES = [".env", ".env.local", ".env.development", ".env.development.local", ".dev.vars"];
+var BASE_IGNORE = "base .gitignore";
 function withoutAttachments(event) {
   if (event.type !== "user-message")
     return event;
@@ -25966,20 +26783,27 @@ function withCarry(context, c) {
   const line = c.moved ? `This worktree started with ${files} the person moved here from ${c.branch} by hand. They are part of the task, not something to clean up.` : `${c.branch} has ${files} the person chose to leave there. This worktree does not have them.`;
   return [...context ?? [], line];
 }
-var FETCH_EVERY_MS = 5 * 60000;
 
 class WorktreeService {
   d;
   spare;
+  trunk;
   archive;
   archiving = new Map;
+  going = new Set;
   countsCache = new Map;
+  handChecked = new Map;
   discoverCache = new Map;
   usage = new Map;
-  lastFetch = new Map;
   constructor(d) {
     this.d = d;
     this.archive = new WorktreeArchive(d.paths.archiveDir);
+    this.trunk = new Trunk({
+      state: d.state,
+      hub: d.hub,
+      counts: (main, defaultBranch, quick) => quick ? Promise.resolve(this.countsQuick(main.id, quick)) : this.counts(main.id, main.path, defaultBranch, false),
+      invalidateCounts: () => this.invalidateCounts()
+    });
     this.spare = new SparePool({
       state: d.state,
       hub: d.hub,
@@ -25988,10 +26812,28 @@ class WorktreeService {
       setupAndStart: (wt, repo) => this.setupAndStart(wt, repo),
       discard: async (id) => {
         await this.discardWorktree(id);
+      },
+      carryDraft: (fromId, repoId) => {
+        const text = this.d.drafts?.text(fromId);
+        const main = this.mainOf(repoId);
+        if (text && main)
+          this.d.drafts?.set(main.id, text);
+      },
+      ready: (repoId) => {
+        const main = this.mainOf(repoId);
+        if (!main)
+          return;
+        if (this.d.runtime.get(main.id)?.procs) {
+          fireAndForget(main.id, this.d.runtime.stopProcs(main.id), "main stops for the spare");
+        }
+        const text = this.d.drafts?.text(main.id);
+        const spare = this.leadSpareOf(repoId);
+        if (text && spare && !this.d.drafts?.text(spare)) {
+          this.d.drafts?.set(spare, text);
+          this.d.drafts?.drop(main.id);
+        }
       }
     });
-    for (const wt of d.state.worktrees)
-      this.refreshLink(wt);
     d.hub.on("agent", (worktreeId, _seq, event) => {
       if (event.type !== "usage")
         return;
@@ -26016,18 +26858,15 @@ class WorktreeService {
     const agent = this.d.agents.require(opts.agent ?? this.d.state.defaultAgent ?? DEFAULT_AGENT_ID).id;
     const profile = this.checkProfile(repo, opts.profile);
     const task = taskText(prompt, attachments);
-    let slug = variant ? `${slugify2(task, false)}-v${variant.index}` : slugify2(task);
-    if (variant && (await git(repo.path, "show-ref", "--verify", `refs/heads/toyon/${slug}`)).ok) {
-      slug = `${slug}-${shortId().slice(0, 3)}`;
-    }
-    const branch = `toyon/${slug}`;
+    const base = titleFrom(task);
+    const title = variant ? `${base} v${variant.index}` : base;
     if (opts.carry && variant && variant.of > 1) {
       throw new UserError(`only a single worktree can take the changes on ${repo.defaultBranch}`);
     }
     const agentPrompt = variant && variant.of >= 2 ? [prompt, variantLens(variant.index)].filter(Boolean).join(`
 
 `) : prompt;
-    const claimed = await this.spare.claim(repoId, branch, slug);
+    const claimed = await this.spare.claim(repoId, title, opts.worktreeId);
     if (claimed) {
       if (variant)
         claimed.variant = variant;
@@ -26041,7 +26880,6 @@ class WorktreeService {
         claimed.model = opts.model;
       if (opts.effort)
         claimed.effort = opts.effort;
-      this.refreshLink(claimed);
       if (profile !== undefined && profile !== resolveRun(repo, claimed).profile) {
         claimed.profile = profile;
         this.restartProcs(claimed, repo);
@@ -26049,22 +26887,31 @@ class WorktreeService {
       const carried = await this.carryMain(repo, claimed, !!opts.carry);
       this.d.state.save();
       this.d.hub.emit("worktreesChanged");
-      this.d.runtime.ensureAgent(claimed).agent.send(agentPrompt, { context: withCarry(context, carried), attachments });
+      const rt = this.d.runtime.ensureAgent(claimed);
+      if (rt.agent.runningAgent !== null && rt.agent.runningAgent !== agent)
+        await rt.agent.restart();
+      rt.agent.send(agentPrompt, { context: withCarry(context, carried), attachments });
       this.scheduleNaming(claimed, task, variant);
       if (carried.unmoved)
         throw new UserError(carried.unmoved);
       return claimed;
     }
-    const wtPath = join21(this.d.paths.worktreesDir, repo.name, slug);
+    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(join23(this.d.paths.worktreesDir, repo.name));
+    const wtPath = join23(this.d.paths.worktreesDir, repo.name, dir);
+    const branch = `toyon/${dir}`;
     await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "-b", branch, wtPath, repo.defaultBranch));
     const wt = {
-      id: shortId(),
+      id,
       repoId,
       path: wtPath,
       branch,
       kind: "worktree",
       proxyPort: await allocateProxyPort(),
-      title: slug,
+      title,
+      unnamed: true,
       createdAt: Date.now(),
       promptedAt: Date.now(),
       agent,
@@ -26084,9 +26931,20 @@ class WorktreeService {
     return wt;
   }
   async carryMain(repo, wt, move) {
+    try {
+      return await this.carryMainOrThrow(repo, wt, move);
+    } catch (e) {
+      log.warn(wt.id, `reading ${repo.defaultBranch}'s changes failed`, e);
+      const unmoved = move ? `the changes on ${repo.defaultBranch} could not be read, so they stayed there` : undefined;
+      return { branch: repo.defaultBranch, moved: false, count: 0, ...unmoved ? { unmoved } : {} };
+    }
+  }
+  async carryMainOrThrow(repo, wt, move) {
     const main = repo.defaultBranch;
-    if (!move)
-      return { branch: main, moved: false, count: (await statusFiles(repo.path)).length };
+    if (!move) {
+      const count = this.countsCache.get(this.mainOf(repo.id)?.id ?? "")?.dirty ?? 0;
+      return { branch: main, moved: false, count };
+    }
     let count = 0;
     const unmoved = await withRepoLock(repo.path, async () => {
       count = (await statusFiles(repo.path)).length;
@@ -26106,6 +26964,9 @@ 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) => !existsSync26(join23(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -26115,12 +26976,14 @@ class WorktreeService {
       }
       log.warn(wt.id, `moving ${main}'s changes failed`, applied.err);
       await git(wt.path, "reset", "--hard");
-      await git(wt.path, "clean", "-fd");
+      for (let i = 0;i < restored.length; i += 100) {
+        await git(wt.path, "--literal-pathspecs", "clean", "-fd", "--", ...restored.slice(i, i + 100));
+      }
       const ref = await entry();
       const back = ref ? await git(repo.path, "stash", "pop", ref) : null;
       return back?.ok ? `the changes on ${main} did not apply in ${wt.title}, so they stayed on ${main}` : `the changes on ${main} did not apply in ${wt.title}; they are kept in git stash as "toyon: into ${wt.title}"`;
     });
-    const mainWt = this.d.state.worktrees.find((w) => w.repoId === repo.id && w.kind === "main");
+    const mainWt = this.mainOf(repo.id);
     if (mainWt)
       this.countsCache.delete(mainWt.id);
     return { branch: main, moved: count > 0 && !unmoved, count, unmoved };
@@ -26138,10 +27001,10 @@ class WorktreeService {
       throw new UserError("that is not a PR number");
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
-    let slug = title;
-    if (existsSync23(join21(this.d.paths.worktreesDir, repo.name, slug)))
+    let slug = branchSlug(title) || "branch";
+    if (existsSync26(join23(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
-    const wtPath = join21(this.d.paths.worktreesDir, repo.name, slug);
+    const wtPath = join23(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)
@@ -26289,7 +27152,7 @@ class WorktreeService {
       if (!name)
         return;
       for (const sibling of [wt, ...siblingsOf(wt, this.d.state.worktrees)]) {
-        await this.rename(sibling.id, `${name}-v${sibling.variant.index}`).catch((e) => {
+        await this.rename(sibling.id, `${name} v${sibling.variant.index}`).catch((e) => {
           log.warn(sibling.id, "variant rename failed", e);
         });
       }
@@ -26317,6 +27180,14 @@ class WorktreeService {
     this.d.drafts?.drop(worktreeId);
   }
   async takeDown(wt, archive, reason) {
+    this.going.add(wt.id);
+    try {
+      return await this.removeAndRecord(wt, archive, reason);
+    } finally {
+      this.going.delete(wt.id);
+    }
+  }
+  async removeAndRecord(wt, archive, reason) {
     const worktreeId = wt.id;
     const repo = this.d.state.requireRepo(wt.repoId);
     await this.d.runtime.stop(worktreeId);
@@ -26324,7 +27195,14 @@ class WorktreeService {
       const k = archive ? await this.keep(repo, wt) : null;
       if (archive && !k)
         throw new UserError(`could not keep ${wt.title}'s work, so it was left in place`);
-      await gitOrThrow(repo.path, "worktree", "remove", "--force", wt.path);
+      if (archive)
+        this.keepPlans(wt);
+      try {
+        await gitOrThrow(repo.path, "worktree", "remove", "--force", wt.path);
+      } catch (e) {
+        rmSync5(this.plansScratch(wt.id), { recursive: true, force: true });
+        throw e;
+      }
       if (hasOwnBranch(wt)) {
         const r = await git(repo.path, "branch", "-D", wt.branch);
         if (!r.ok)
@@ -26332,7 +27210,6 @@ class WorktreeService {
       }
       return k;
     });
-    this.dropLink(wt);
     const sessionId = this.d.state.session(worktreeId);
     this.d.state.removeWorktree(worktreeId);
     releasePort(wt.proxyPort);
@@ -26348,7 +27225,7 @@ class WorktreeService {
     return archived;
   }
   async keep(repo, wt) {
-    const index = join21(this.d.paths.archiveDir, `${wt.id}.index`);
+    const index = join23(this.d.paths.archiveDir, `${wt.id}.index`);
     const kept = await keepState(repo.path, wt.path, archiveRef(wt.id), index);
     if (!kept)
       log.warn(wt.id, "could not keep its git state");
@@ -26356,8 +27233,21 @@ class WorktreeService {
       log.warn(wt.id, "could not keep its uncommitted changes: only its commits are archived");
     return kept;
   }
+  plansScratch(worktreeId) {
+    return join23(this.d.paths.archiveDir, `${worktreeId}.plans`);
+  }
+  keepPlans(wt) {
+    const from = join23(wt.path, PLANS_DIR);
+    if (!existsSync26(from))
+      return;
+    try {
+      cpSync(from, this.plansScratch(wt.id), { recursive: true });
+    } catch (e) {
+      log.warn(wt.id, "could not keep its plans", e);
+    }
+  }
   archiveChat(wt, repo, kept, sessionId, reason) {
-    const files = this.chatFiles(wt.id);
+    const files = { ...this.chatFiles(wt.id), plans: this.plansScratch(wt.id) };
     const prompt = firstPrompt(files.transcript);
     const cost = (this.usage.get(wt.id) ?? lastUsage(files.transcript))?.cost;
     const rec = {
@@ -26370,14 +27260,15 @@ class WorktreeService {
       ...kept ? { kept } : {},
       ...reason ? { auto: reason } : {}
     };
+    let at;
     try {
-      this.archive.put(rec, files);
+      at = this.archive.put(rec, files);
     } catch (e) {
       log.warn(wt.id, "could not archive its chat; the files stay where they were", e);
       return null;
     }
     this.d.hub.emit("archiveChanged", repo.id);
-    return summarize(rec, repo.id);
+    return summarize(rec, repo.id, at.transcript);
   }
   chatFiles(worktreeId) {
     return {
@@ -26397,7 +27288,6 @@ class WorktreeService {
   async forgetGone(wt) {
     const repo = this.d.state.repo(wt.repoId);
     const sessionId = this.d.state.session(wt.id);
-    this.dropLink(wt);
     this.d.state.removeWorktree(wt.id);
     if (!repo || wt.kind !== "worktree") {
       this.deleteChat(wt.id);
@@ -26436,7 +27326,7 @@ class WorktreeService {
   }
   archivedAttachment(archiveId, file) {
     const files = this.archive.chatFiles(archiveId);
-    return files && isAttachmentFile(file) ? join21(files.attachments, file) : null;
+    return files && isAttachmentFile(file) ? join23(files.attachments, file) : null;
   }
   archivedGit(archiveId) {
     const rec = this.archive.get(archiveId);
@@ -26457,6 +27347,9 @@ class WorktreeService {
     }
   }
   async archivedFile(archiveId, path, ref) {
+    const plan = ref ? null : this.archive.planFile(archiveId, path);
+    if (plan !== null)
+      return { before: plan, after: plan };
     const kept = this.archivedGit(archiveId);
     return kept ? kept.file(path, ref) : null;
   }
@@ -26476,7 +27369,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 = existsSync23(old.path) ? join21(dirname8(old.path), `${basename6(old.path)}-${shortId().slice(0, 4)}`) : old.path;
+    const path = existsSync26(old.path) ? join23(dirname9(old.path), freeSlot(dirname9(old.path)).dir) : old.path;
     const branch = await withRepoLock(repo.path, async () => {
       if (!await commitOf(repo.path, archiveRef(old.id))) {
         throw new UserError(`${old.title}'s kept commits are gone from git`);
@@ -26502,7 +27395,7 @@ class WorktreeService {
       }
       return name;
     });
-    const { variant: _variant, linkPath: _linkPath, ...rest } = old;
+    const { variant: _variant, ...rest } = old;
     const wt = {
       ...rest,
       repoId: repo.id,
@@ -26513,7 +27406,7 @@ class WorktreeService {
       ...createdBy ? { createdBy } : {}
     };
     try {
-      this.archive.take(old.id, this.chatFiles(old.id));
+      this.archive.take(old.id, { ...this.chatFiles(old.id), plans: join23(path, PLANS_DIR) });
     } catch (e) {
       log.warn(old.id, "could not move its chat back out of the archive", e);
     }
@@ -26523,7 +27416,6 @@ class WorktreeService {
     if (!dropped.ok)
       log.warn(old.id, `could not drop its archive ref: ${dropped.err}`);
     this.countsCache.delete(wt.id);
-    this.refreshLink(wt);
     this.launch(wt, repo, repo.path);
     if (message)
       this.d.runtime.ensureAgent(wt).agent.send(message.text, { attachments: message.attachments });
@@ -26536,12 +27428,12 @@ class WorktreeService {
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync23(repoPath)) {
+    if (rec.kept && existsSync26(repoPath)) {
       const r = await git(repoPath, "update-ref", "-d", archiveRef(archiveId));
       if (!r.ok)
         log.warn(archiveId, `could not drop its archive ref: ${r.err}`);
     }
-    if (rec.worktree.lands?.length && existsSync23(repoPath))
+    if (rec.worktree.lands?.length && existsSync26(repoPath))
       await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
     this.d.drafts?.drop(archiveId);
@@ -26558,55 +27450,24 @@ class WorktreeService {
     const clean = cleanTitle2(title);
     if (!clean)
       return;
+    const slug = branchSlug(clean);
     await withRepoLock(repo.path, async () => {
-      let branch = `toyon/${clean}`;
-      if (branch !== wt.branch) {
+      let branch = `toyon/${slug}`;
+      if (slug && branch !== wt.branch) {
         let n = 2;
         while (!(await git(wt.path, "branch", "-m", wt.branch, branch)).ok) {
           if (n > 5)
             return;
-          branch = `toyon/${clean}-${n++}`;
+          branch = `toyon/${slug}-${n++}`;
         }
         wt.branch = branch;
       }
       wt.title = clean;
+      delete wt.unnamed;
     });
-    this.refreshLink(wt);
     this.d.state.save();
     this.d.hub.emit("worktreesChanged");
   }
-  refreshLink(wt) {
-    if (!hasOwnBranch(wt))
-      return;
-    const name = wt.branch.replace(/^toyon\//, "");
-    const desired = wt.kind === "worktree" ? join21(dirname8(wt.path), name) : wt.path;
-    if (wt.linkPath && wt.linkPath !== desired)
-      this.dropLink(wt);
-    if (desired === wt.path)
-      return;
-    try {
-      const st = lstatSync(desired, { throwIfNoEntry: false });
-      if (st && !(st.isSymbolicLink() && readlinkSync(desired) === wt.path))
-        return;
-      if (!st)
-        symlinkSync(wt.path, desired);
-      wt.linkPath = desired;
-    } catch (e) {
-      log.warn(wt.id, "could not link the title to the directory", e);
-    }
-  }
-  dropLink(wt) {
-    const p = wt.linkPath;
-    wt.linkPath = undefined;
-    if (!p)
-      return;
-    try {
-      if (lstatSync(p, { throwIfNoEntry: false })?.isSymbolicLink())
-        unlinkSync(p);
-    } catch (e) {
-      log.warn(wt.id, "could not remove the title link", e);
-    }
-  }
   async pickVariant(worktreeId) {
     const wt = this.d.state.worktree(worktreeId);
     if (!wt?.variant)
@@ -26671,10 +27532,19 @@ class WorktreeService {
       this.d.runtime.markSetup(wt.id, false);
     }
   }
+  async mirrorBaseIgnore(repo) {
+    const src = join23(repo.path, ".gitignore");
+    const tracked = existsSync26(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
+    const mirror = existsSync26(src) && !tracked;
+    const lines = mirror ? readFileSync16(src, "utf8").split(`
+`).filter((l) => l.trim() !== "") : [];
+    await excludeBlock(repo.path, BASE_IGNORE, lines);
+  }
   async setupThenStart(wt, repo, depsSource, { setupCommands = true }) {
-    const srcNm = join21(depsSource, "node_modules");
-    const dstNm = join21(wt.path, "node_modules");
-    if (existsSync23(srcNm) && !existsSync23(dstNm)) {
+    await this.mirrorBaseIgnore(repo);
+    const srcNm = join23(depsSource, "node_modules");
+    const dstNm = join23(wt.path, "node_modules");
+    if (existsSync26(srcNm) && !existsSync26(dstNm)) {
       const started = Date.now();
       const attempts = [
         ["clonefile", ["-Rc", srcNm, dstNm]],
@@ -26690,10 +27560,10 @@ class WorktreeService {
       }
     }
     for (const f of LOCAL_CONFIG_FILES) {
-      const src = join21(depsSource, f);
-      if (!existsSync23(src) || existsSync23(join21(wt.path, f)))
+      const src = join23(depsSource, f);
+      if (!existsSync26(src) || existsSync26(join23(wt.path, f)))
         continue;
-      const r = await run("cp", [src, join21(wt.path, f)], wt.path);
+      const r = await run("cp", [src, join23(wt.path, f)], wt.path);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `copied ${f}`);
       else
@@ -26758,10 +27628,42 @@ ${wt.landing.body}` : s;
   async commitIfDirty(wt, typed) {
     if ((await statusFiles(wt.path)).length === 0)
       return null;
-    const result = await commitWorktree(wt.path, this.commitMessage(wt, typed));
-    if (result.ok)
+    return this.commitRecorded(wt, this.commitMessage(wt, typed));
+  }
+  async commitRecorded(wt, message) {
+    const result = await commitWorktree(wt.path, message);
+    if (result.ok) {
+      await this.verdictSurvives(wt, { dropMessage: true });
       this.headMoved(wt.id);
-    return result;
+      return result;
+    }
+    if (!result.output?.trim() || !this.d.record)
+      return result;
+    const subject = message.split(`
+`, 1)[0] ?? "";
+    try {
+      this.d.record(wt.id, `git commit -m ${JSON.stringify(subject)}`, result.output, result.exit ?? null);
+    } catch (e) {
+      log.warn(wt.id, `could not put the refused commit on the transcript: ${e instanceof Error ? e.message : e}`);
+      return result;
+    }
+    return { ...result, message: "commit refused: what git and its hooks printed is on the chat" };
+  }
+  async verdictSurvives(wt, opts) {
+    const l = wt.landing;
+    if (!l || l.check === "pending")
+      return;
+    const { subject, body, ...kept } = l;
+    const message = opts.dropMessage ? {} : { ...subject ? { subject } : {}, ...body ? { body } : {} };
+    this.setLanding(wt.id, { ...kept, ...message, fingerprint: await treeFingerprint(wt.path) });
+  }
+  async landedByHand(wt, mark) {
+    const repo = this.d.state.requireRepo(wt.repoId);
+    log.info(wt.id, `landed on ${repo.defaultBranch} outside toyon: ${mark.base.slice(0, 7)}..${mark.tip.slice(0, 7)}`);
+    await this.noteLand(repo, wt, mark);
+    await this.restartFromMain(wt, repo.defaultBranch);
+    this.setLanding(wt.id, undefined);
+    this.setLanded(wt.id, true);
   }
   async land(worktreeId, message) {
     const { wt, repo } = this.landable(worktreeId, "land");
@@ -26772,8 +27674,24 @@ ${wt.landing.body}` : s;
 ${wt.landing.body}` : wt.landing.subject : undefined;
     if (policy.land === "pr") {
       if (wt.pr?.state === "open") {
-        const result = await mergePr(wt.path, wt.pr.number, policy.merge);
-        return { result };
+        const dirty = (await statusFiles(wt.path)).length > 0;
+        const missing = dirty || (await aheadUpstream(wt.path) ?? 0) > 0;
+        if (!missing)
+          return { result: await mergePr(wt.path, wt.pr.number, policy.merge) };
+        const committed = await this.commitIfDirty(wt, message);
+        if (committed && !committed.ok)
+          return { result: committed };
+        const taken = await takeMainIn(wt.path, repo.defaultBranch, own);
+        if (!taken.ok)
+          return { result: taken };
+        this.headMoved(wt.id);
+        const pushed = await pushBranch(wt.path, wt.branch);
+        if (!pushed.ok)
+          return { result: pushed };
+        this.headMoved(wt.id);
+        this.setLanding(wt.id, undefined);
+        const did = committed ? "committed and pushed" : "pushed";
+        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)
@@ -26799,10 +27717,12 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       return { result };
     }
     let mergedHere = false;
+    let committedHere = false;
     const result = await withRepoLock(repo.path, async () => {
       const committed = await this.commitIfDirty(wt, message);
       if (committed && !committed.ok)
         return committed;
+      committedHere = committed !== null;
       if (policy.land === "push") {
         const pulled = await fastForwardMain(repo.path, repo.defaultBranch);
         if (!pulled.ok && !/no upstream/.test(pulled.message))
@@ -26835,8 +27755,9 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     if (!result.ok)
       return { result };
     const archiveIds = siblingsOf(wt, this.d.state.worktrees).map((w) => w.id);
-    const where = policy.land === "push" ? `${repo.defaultBranch}, pushed` : repo.defaultBranch;
-    return { result: { ...result, message: `${wt.title} is on ${where}` }, archiveIds };
+    const did = committedHere ? "committed and merged" : "merged";
+    const then = policy.land === "push" ? " and pushed" : "";
+    return { result: { ...result, message: `${did} into ${repo.defaultBranch}${then}` }, archiveIds };
   }
   async noteLand(repo, wt, mark) {
     if (!mark)
@@ -26882,6 +27803,8 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       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)
@@ -26889,8 +27812,11 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const repo = this.d.state.requireRepo(r.repoId);
     const own = r.wt ? hasOwnBranch(r.wt) : false;
     const result = await withRepoLock(repo.path, () => takeMainIn(r.path, repo.defaultBranch, own));
-    if (result.ok)
+    if (result.ok) {
       this.headMoved(worktreeId);
+      if (r.wt)
+        await this.verdictSurvives(r.wt, { dropMessage: false });
+    }
     return { result, defaultBranch: repo.defaultBranch };
   }
   async pull(worktreeId) {
@@ -26910,10 +27836,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const m = message.trim();
     if (!m)
       throw new UserError("commit message required");
-    const result = await commitWorktree(wt.path, m);
-    if (result.ok)
-      this.headMoved(wt.id);
-    return result;
+    return this.commitRecorded(wt, m);
   }
   setEmpty(wt, empty) {
     if (wt.empty === empty)
@@ -26922,23 +27845,11 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     this.d.state.save();
     this.d.hub.emit("worktreesChanged");
   }
-  async mainCounts(path) {
-    const behind = await behindUpstream(path);
-    if (behind === null)
-      return {};
-    const last = this.lastFetch.get(path) ?? 0;
-    if (Date.now() - last > FETCH_EVERY_MS) {
-      this.lastFetch.set(path, Date.now());
-      fireAndForget("fetch", run(GIT, ["fetch", "--quiet"], path, NO_PROMPT).then((r) => {
-        if (!r.ok) {
-          log.warn("fetch", `could not fetch ${path}: ${r.err.slice(0, 200)}`);
-          return;
-        }
-        this.invalidateCounts();
-        this.d.hub.emit("worktreesChanged");
-      }));
-    }
-    return { behind };
+  syncTrunk(repoId) {
+    return this.trunk.sync(repoId);
+  }
+  trunks(opts = {}) {
+    return this.trunk.all(opts);
   }
   usageFor(worktreeId) {
     const known = this.usage.get(worktreeId);
@@ -27004,15 +27915,26 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const cached = this.countsCache.get(id);
     if (cached && Date.now() - cached.at < 1e4)
       return cached;
+    if (this.going.has(id))
+      return cached ?? {};
     try {
-      const ab = countable ? await aheadBehind(path, defaultBranch) : await this.mainCounts(path);
-      const fresh = { ...ab, dirty: (await statusFiles(path)).length, at: Date.now() };
+      const ab = countable ? await aheadBehind(path, defaultBranch) : await this.trunk.behind(id, path);
+      const dirty = (await statusFiles(path)).length;
+      const unpushed = await this.unpushed(id, path);
+      if (this.going.has(id))
+        return cached ?? {};
+      const fresh = { ...ab, ...unpushed === undefined ? {} : { unpushed }, dirty, at: Date.now() };
       this.countsCache.set(id, fresh);
       return fresh;
     } catch {
       return cached ?? {};
     }
   }
+  async unpushed(id, path) {
+    if (this.d.state.worktree(id)?.pr?.state !== "open")
+      return;
+    return await aheadUpstream(path) ?? undefined;
+  }
   async freshCounts(worktreeId) {
     const wt = this.d.state.worktree(worktreeId);
     const repo = wt && this.d.state.repo(wt.repoId);
@@ -27024,8 +27946,6 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   readable(id) {
     const wt = this.d.state.worktree(id);
     if (wt) {
-      if (wt.kind === "spare")
-        return null;
       const { defaultBranch } = this.d.state.requireRepo(wt.repoId);
       return { id, repoId: wt.repoId, path: wt.path, name: wt.title, branch: wt.branch, defaultBranch, wt };
     }
@@ -27044,16 +27964,20 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     };
   }
   async gitStatus(worktreeId) {
+    if (this.going.has(worktreeId))
+      return null;
     const r = this.readable(worktreeId);
     if (!r)
       return this.archivedStatus(worktreeId);
     try {
       const isMain = r.wt?.kind === "main";
-      const [files, counts, head] = await Promise.all([
+      const [files, ab, unpushed, head] = await Promise.all([
         statusFilesWithCounts(r.path),
         isMain ? Promise.resolve({}) : aheadBehind(r.path, r.defaultBranch),
+        this.unpushed(worktreeId, r.path),
         git(r.path, "rev-parse", "HEAD")
       ]);
+      const counts = { ...ab, ...unpushed === undefined ? {} : { unpushed } };
       const ahead = counts.ahead ?? 0;
       const committed = !isMain && ahead > 0 ? await committedFiles(r.path, r.defaultBranch) : undefined;
       if (r.wt?.landed && (files.length > 0 || ahead > 0)) {
@@ -27061,10 +27985,25 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
         if (r.wt.pr)
           this.setPr(r.wt.id, undefined);
       }
-      if (r.wt?.landing && r.wt.landing.check !== "pending" && r.wt.landing.fingerprint !== await treeFingerprint(r.path))
-        this.setLanding(r.wt.id, undefined);
+      if (r.wt && !isMain && !r.wt.landed && hasOwnBranch(r.wt) && files.length === 0 && ahead === 0 && head.ok && this.handChecked.get(r.wt.id) !== head.out) {
+        this.handChecked.set(r.wt.id, head.out);
+        const mark = await handLanding(r.path, r.wt.branch, r.defaultBranch, r.wt.lands?.at(-1)?.tip);
+        if (mark) {
+          await this.landedByHand(r.wt, mark);
+          return this.gitStatus(worktreeId);
+        }
+      }
+      if (r.wt?.landing && r.wt.landing.check !== "pending") {
+        const moved = r.wt.landing.fingerprint !== await treeFingerprint(r.path);
+        if (moved !== !!r.wt.landing.stale) {
+          const { stale: _was, ...rest } = r.wt.landing;
+          this.setLanding(r.wt.id, moved ? { ...rest, stale: true } : rest);
+        }
+      }
       if (r.wt && isMain)
         this.setEmpty(r.wt, files.length === 0 ? await treeEmpty(r.path) : false);
+      if (this.going.has(worktreeId))
+        return null;
       this.noteCounts(worktreeId, isMain, files.length, counts);
       return { files, committed, head: head.ok ? head.out : undefined, ...counts };
     } catch (e) {
@@ -27078,8 +28017,9 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       return;
     const ahead = main ? prev?.ahead : ab.ahead;
     const behind = main ? prev?.behind : ab.behind;
-    this.countsCache.set(id, { ahead, behind, dirty, at: Date.now() });
-    if (prev?.dirty !== dirty || prev?.ahead !== ahead || prev?.behind !== behind)
+    const unpushed = main ? prev?.unpushed : ab.unpushed;
+    this.countsCache.set(id, { ahead, behind, unpushed, dirty, at: Date.now() });
+    if (prev?.dirty !== dirty || prev?.ahead !== ahead || prev?.behind !== behind || prev?.unpushed !== unpushed)
       this.d.hub.emit("worktreesChanged");
   }
   async gitLog(worktreeId) {
@@ -27106,7 +28046,9 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       await this.restore(worktreeId, msg.clientId, { text: msg.text, attachments: msg.attachments });
       return;
     }
-    this.requireRun(worktreeId);
+    const wt = this.requireRun(worktreeId);
+    if (wt.kind === "main")
+      throw new UserError("nothing runs on main: the plus starts a worktree for it");
     const agent = this.d.runtime.agentFor(worktreeId);
     if (!agent)
       throw new UserError("worktree still starting; try again in a moment");
@@ -27128,14 +28070,11 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       setTimeout(() => this.d.hub.emit("worktreesChanged"), 0);
     return [...owned, ...found];
   }
-  spares() {
-    return this.d.state.worktrees.filter((wt) => wt.kind === "spare").map((wt) => ({
-      repoId: wt.repoId,
-      id: wt.id,
-      path: wt.path,
-      proxyPort: wt.proxyPort,
-      ready: this.d.runtime.get(wt.id)?.proxy != null && this.spare.current(wt.repoId)?.worktreeId === wt.id
-    }));
+  mainOf(repoId) {
+    return mainOf(this.d.state, repoId);
+  }
+  leadSpareOf(repoId) {
+    return this.spare.current(repoId)?.worktreeId ?? null;
   }
   countsQuick(id, quick) {
     const c = this.countsCache.get(id);
@@ -27144,11 +28083,17 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     quick.missed = true;
     return {};
   }
+  isRow(wt) {
+    if (wt.kind === "worktree")
+      return true;
+    const lead = this.leadSpareOf(wt.repoId);
+    return wt.kind === "spare" ? lead === wt.id : lead === null;
+  }
   async ownedRows(quick) {
-    return Promise.all(this.d.state.worktrees.filter((wt) => wt.kind !== "spare").map(async (wt) => {
+    return Promise.all(this.d.state.worktrees.filter((wt) => this.isRow(wt)).map(async (wt) => {
       const rt = this.d.runtime.get(wt.id);
       const { defaultBranch } = this.d.state.requireRepo(wt.repoId);
-      const { ahead, behind, dirty } = quick ? this.countsQuick(wt.id, quick) : await this.counts(wt.id, wt.path, defaultBranch, !isMain(wt));
+      const { ahead, behind, unpushed, dirty } = quick ? this.countsQuick(wt.id, quick) : await this.counts(wt.id, wt.path, defaultBranch, !isMain(wt));
       return {
         id: wt.id,
         repoId: wt.repoId,
@@ -27161,10 +28106,13 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
         login: !!rt?.login,
         ahead,
         behind,
+        unpushed,
         dirty,
         queued: rt?.agent.queueLength || undefined,
         unseen: isUnseen(wt) || undefined,
-        usage: this.usageFor(wt.id)
+        usage: this.usageFor(wt.id),
+        transcript: transcriptPathFor(this.d.paths.transcriptsDir, wt.id),
+        sessionId: this.d.state.session(wt.id)
       };
     }));
   }
@@ -27269,7 +28217,7 @@ class ArchiveSweep {
 // ../daemon/src/index.ts
 process.on("unhandledRejection", (e) => log.error("daemon", "unhandled rejection", e));
 process.on("uncaughtException", (e) => log.error("daemon", "uncaught exception", e));
-var here = dirname9(fileURLToPath(import.meta.url));
+var here = dirname10(fileURLToPath(import.meta.url));
 var {
   shellDist: SHELL_DIST,
   bridgeJs: BRIDGE_JS,
@@ -27323,29 +28271,39 @@ var runtime = new RuntimeRegistry({
   bridgeScript: () => bridge.get(),
   remote,
   grant: previewGrant(token),
-  viewed: (id) => idle.isViewed(id)
+  viewed: (id) => idle.isViewed(id),
+  shown: (id) => idle.isShown(id),
+  mainLeads: (repoId) => worktrees.spare.current(repoId) === null
 });
 var drafts = new DraftStore({ file: paths.draftsFile, hub });
-var worktrees = new WorktreeService({ state, hub, runtime, paths, agents, drafts });
+var exec = new ExecService({ state, runtime });
+var worktrees = new WorktreeService({
+  state,
+  hub,
+  runtime,
+  paths,
+  agents,
+  drafts,
+  record: (id, command, text, exit) => exec.record(id, command, text, exit)
+});
 var turns = new TurnService({
   state,
   hub,
   transcript: (id) => runtime.agentFor(id)?.transcript() ?? [],
-  summarize: makeRecapper(runtime, agents, state),
   hold: (id, tag) => runtime.hold(id, tag),
   release: (id, tag) => runtime.release(id, tag)
 });
 var files = new FileService(state, runtime, (id) => worktrees.readable(id));
 var design = new DesignService((id) => worktrees.readable(id));
 var routes = new RouteService({ state, hub, readable: (id) => worktrees.readable(id) });
-var exec = new ExecService({ state, runtime });
-new LandingService({
+var landing = new LandingService({
   state,
   hub,
   worktrees,
   transcript: (id) => runtime.agentFor(id)?.transcript() ?? [],
-  check: (id, command) => exec.exec(id, command, CHECK_TOOL),
-  judge: makeLander(runtime, agents, state)
+  check: (id, command, opts) => exec.exec(id, command, CHECK_TOOL, opts),
+  judge: makeLander(runtime, agents, state),
+  recap: makeAnswerRecapper(runtime, agents, state)
 });
 var refs = new RefSearch({ state });
 var chats = new ChatSearch({
@@ -27357,7 +28315,7 @@ var chats = new ChatSearch({
 var prs = new PrService({ state, hub, worktrees, view: viewPr });
 var self = new SelfWatch(SOURCE_ROOT);
 await self.start();
-var afterLand = new AfterLand({ state, hub, self });
+var afterLand = new AfterLand({ state, hub, self, settled: () => idle.settled() });
 var repos = new RepoRegistry({ state, hub, runtime, worktrees, afterLand, self, drafts });
 var idle = new IdlePolicy({
   runtime,
@@ -27426,6 +28384,7 @@ var { branded, stop: stopServer } = startServer({
     chats,
     drafts,
     prs,
+    landing,
     themes,
     agents,
     accounts,
@@ -27449,14 +28408,12 @@ bridge.setShellOrigins([
   ],
   ...remote ? [`https://${remote.host}`] : []
 ]);
-writeFileSync9(paths.pidFile, `${process.pid}
+writeFileSync10(paths.pidFile, `${process.pid}
 `);
 var stopLagSampler = startLagSampler();
+await runtime.reclaimOrphans();
 await repos.boot();
-drafts.prune((id) => {
-  const repoId = draftRepoOf(id);
-  return repoId ? !!state.repo(repoId) : !!state.worktree(id) || worktrees.hasArchived(id);
-});
+drafts.prune((id) => !!state.worktree(id) || worktrees.hasArchived(id));
 idle.boot();
 fireAndForget("agents", agents.installMissing().then(() => probe.missing()), "agent adapter install");
 var repoArg = process.argv[2];
@@ -27497,6 +28454,7 @@ async function shutdown(signal, opts = {}) {
   drafts.flush();
   const deadline = new Promise((resolve) => setTimeout(resolve, 5000));
   await Promise.race([runtime.shutdown(), deadline]);
+  state.flushGroups();
   rmSync6(paths.pidFile, { force: true });
   if (opts.respawn) {
     await Bun.sleep(250);