toyon 0.1.0 → 0.3.0

package/dist/daemon.js

@@ -1,6 +1,6 @@
 // @bun
 // ../daemon/src/index.ts
-import { rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname9 } from "path";
 import { fileURLToPath } from "url";
 
@@ -13,6 +13,111 @@ function isWriteTool(ev) {
   return ev.kind ? WRITE_KINDS.has(ev.kind) : WRITE_TOOLS.has(ev.name);
 }
 
+// ../shared/src/model.ts
+var DEFAULT_PERMISSION_MODE = "auto";
+function hasOwnBranch(wt) {
+  return wt.branch.startsWith("toyon/");
+}
+function isUnseen(wt) {
+  return wt.unread === true || wt.lastTurn != null && (wt.seenAt == null || wt.seenAt < wt.lastTurn.at);
+}
+var SHELL_STREAM = "shell";
+var LOGIN_STREAM = "login";
+function streamKey(worktreeId, stream) {
+  return `${worktreeId}/${stream}`;
+}
+
+// ../shared/src/worktree-caps.ts
+function isMain(wt) {
+  return wt.kind === "main";
+}
+function canArchive(wt) {
+  return wt.kind === "worktree";
+}
+function canRename(wt) {
+  return wt.kind === "worktree" && hasOwnBranch(wt);
+}
+function canLand(wt) {
+  return wt.kind === "worktree" && wt.from?.kind !== "pr";
+}
+function canGraft(wt) {
+  return wt.kind === "worktree";
+}
+
+// ../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}`;
+function railOrder(rows) {
+  const units = [];
+  const groups = new Map;
+  for (const row of rows) {
+    const w = row.worktree;
+    const key = railUnitOf(w);
+    const unit = groups.get(key);
+    if (unit) {
+      unit.rows.push(row);
+      unit.at = Math.max(unit.at, sentAt(w));
+      continue;
+    }
+    const fresh = { tier: tierOf(w), at: sentAt(w), rows: [row] };
+    units.push(fresh);
+    groups.set(key, fresh);
+  }
+  units.sort((a, b) => a.tier - b.tier || b.at - a.at);
+  return units.flatMap((u) => u.rows.length > 1 ? u.rows.sort((a, b) => (a.worktree.variant?.index ?? 0) - (b.worktree.variant?.index ?? 0)) : u.rows);
+}
+
+// ../shared/src/archiveRule.ts
+var ARCHIVE_KEEP_RECENT = 5;
+function archiveReason(wt, f) {
+  const group = wt.variant ? f.rows.filter((w) => w.variant?.group === wt.variant?.group) : [wt];
+  const decided = group.some((w) => !!w.lands?.length);
+  const lost = decided && !wt.lands?.length;
+  if (decided) {
+    if (!nothingToKeep(wt, f, lost))
+      return null;
+  } else if (!group.every((w) => nothingToKeep(w, f, false)))
+    return null;
+  if (unitsAhead(wt, f.rows) < ARCHIVE_KEEP_RECENT)
+    return null;
+  const what = lost ? "a sibling landed" : wt.landed ? "landed" : "no changes";
+  return `${what}, not opened in ${duration(f.afterMs)}`;
+}
+function nothingToKeep(w, f, lost) {
+  if (w.kind !== "worktree" || !hasOwnBranch(w))
+    return false;
+  if (w.lastTurn?.end !== "done" || isUnseen(w))
+    return false;
+  if (w.planned || w.pr?.state === "open")
+    return false;
+  if (f.viewed(w.id) || f.pending(w.id) || f.drafted(w.id))
+    return false;
+  if (f.now - (w.viewedAt ?? w.createdAt) < f.afterMs)
+    return false;
+  const c = f.counts(w.id);
+  return c.dirty === 0 && (lost ? c.ahead !== undefined : c.ahead === 0);
+}
+function unitsAhead(wt, rows) {
+  const tasks = railOrder(rows.filter((w) => w.kind === "worktree").map((worktree) => ({ worktree })));
+  const mine = railUnitOf(wt);
+  const seen = new Set;
+  for (const { worktree: w } of tasks) {
+    const unit = railUnitOf(w);
+    if (unit === mine)
+      return seen.size;
+    seen.add(unit);
+  }
+  return seen.size;
+}
+function duration(ms) {
+  if (ms >= 60 * 60000)
+    return `${Math.round(ms / (60 * 60000))}h`;
+  if (ms >= 60000)
+    return `${Math.round(ms / 60000)} min`;
+  return `${Math.round(ms / 1000)}s`;
+}
+
 // ../shared/src/attachment.ts
 var ATTACHMENT_KINDS = ["image", "paste", "pick"];
 var ATTACHMENT_LIMITS = { image: 6, paste: 4, pick: 8 };
@@ -40,12 +145,17 @@ var CONFIG_DIR = ".toyon";
 function isLocalConfigFile(rel) {
   return rel === CONFIG_FILES.folder.local || rel === CONFIG_FILES.root.local;
 }
+function configSibling(rel, kind) {
+  const place = Object.values(CONFIG_FILES).find((p) => p.shared === rel || p.local === rel) ?? CONFIG_FILES.folder;
+  return place[kind];
+}
 
 // ../shared/src/daemon.ts
 var DAEMON_FILES = {
   token: "token",
   pid: "daemon.pid",
   state: "state.json",
+  drafts: "drafts.json",
   log: "daemon.log",
   remote: "remote.json"
 };
@@ -159,6 +269,11 @@ 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";
@@ -171,19 +286,8 @@ function landPolicy(config) {
   };
 }
 
-// ../shared/src/model.ts
-var DEFAULT_PERMISSION_MODE = "auto";
-function hasOwnBranch(wt) {
-  return wt.branch.startsWith("toyon/");
-}
-var SHELL_STREAM = "shell";
-var LOGIN_STREAM = "login";
-function streamKey(worktreeId, stream) {
-  return `${worktreeId}/${stream}`;
-}
-
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 43;
+var PROTOCOL_VERSION = 56;
 var FILE_MAX_CHARS = 5000000;
 var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var IMAGE_MAX_EDGE = 2576;
@@ -1126,7 +1230,7 @@ var nanoid = /^[a-zA-Z0-9_-]{21}$/;
 function nanoidOfLength(length) {
   return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);
 }
-var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+var duration2 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
 var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
 var uuid = (version) => {
   if (!version)
@@ -1919,7 +2023,7 @@ var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
   $ZodStringFormat.init(inst, def);
 });
 var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
-  def.pattern ?? (def.pattern = duration);
+  def.pattern ?? (def.pattern = duration2);
   $ZodStringFormat.init(inst, def);
 });
 var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
@@ -6221,6 +6325,7 @@ var toyonConfigSchema = object({
   setup: array(shellCommand).max(50).optional(),
   run: record(declaredProcName, shellCommand),
   check: shellCommand.optional(),
+  afterLand: array(shellCommand).max(50).optional(),
   land: landConfigSchema.optional(),
   preview: procName.optional(),
   profiles: record(procName, runProfileSchema).optional(),
@@ -6255,9 +6360,11 @@ var variantSchema = object({ group: string2(), index: number2().int().min(1), of
 var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("subscribe"), worktreeId: id }),
   object({ t: literal("unsubscribe"), worktreeId: id }),
+  object({ t: literal("view"), worktreeId: id.nullable() }),
   object({
     t: literal("chat"),
     worktreeId: id,
+    clientId: string2().max(64).optional(),
     text: prose,
     context: prose.optional(),
     attachments
@@ -6267,7 +6374,6 @@ var clientMsgSchema = discriminatedUnion("t", [
     clientId: string2().max(64).optional(),
     repoId: id,
     prompt,
-    baseWorktreeId: id.optional(),
     variant: variantSchema.optional(),
     context: prose.optional(),
     attachments,
@@ -6275,7 +6381,8 @@ var clientMsgSchema = discriminatedUnion("t", [
     profile: string2().max(100).optional(),
     mode: permissionModeSchema.optional(),
     model: string2().max(200).optional(),
-    effort: string2().max(100).optional()
+    effort: string2().max(100).optional(),
+    carry: boolean2().optional()
   }),
   object({
     t: literal("batch-worktrees"),
@@ -6289,12 +6396,13 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("set-worktree-model"), worktreeId: id, model: string2().max(200) }),
   object({ t: literal("set-worktree-effort"), worktreeId: id, effort: string2().max(100) }),
   object({ t: literal("set-worktree-profile"), worktreeId: id, profile: string2().max(100) }),
-  object({ t: literal("remove-worktree"), worktreeId: id }),
+  object({ t: literal("archive-worktree"), worktreeId: id }),
   object({ t: literal("list-archived"), repoId: id }),
   object({
     t: literal("restore-worktree"),
     archiveId: id,
-    clientId: string2().max(64).optional()
+    clientId: string2().max(64).optional(),
+    message: object({ text: prose, attachments }).optional()
   }),
   object({ t: literal("delete-archived"), archiveId: id }),
   object({
@@ -6310,6 +6418,9 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("commit"), worktreeId: id, message: string2().max(5000) }),
   object({ t: literal("graft"), targetId: id, sourceIds: array(id).min(1).max(20) }),
   object({ t: literal("sync-main"), worktreeId: id }),
+  object({ t: literal("run-after-land"), repoId: id }),
+  object({ t: literal("restart-daemon") }),
+  object({ t: literal("update-now") }),
   object({ t: literal("pull-main"), worktreeId: id }),
   object({
     t: literal("write-file"),
@@ -6329,6 +6440,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("stop-agent"), worktreeId: id }),
   object({ t: literal("seen"), worktreeId: id }),
   object({ t: literal("mark-unread"), worktreeId: id }),
+  object({ t: literal("set-draft"), boxId: id, text: prose, clientId: string2().max(64).optional() }),
   object({ t: literal("refresh-git"), repoId: id }),
   object({ t: literal("visit"), worktreeId: id, path: routePath, title: pageTitle.optional() }),
   object({ t: literal("page-title"), worktreeId: id, path: routePath, title: pageTitle }),
@@ -6337,7 +6449,12 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("unqueue"), worktreeId: id, index: number2().int().min(0) }),
   object({ t: literal("changed-ranges"), worktreeId: id, path: relPath }),
   object({ t: literal("rename-worktree"), worktreeId: id, title: string2().min(1).max(200) }),
-  object({ t: literal("confirm-config"), repoId: id, config: toyonConfigSchema }),
+  object({
+    t: literal("confirm-config"),
+    repoId: id,
+    config: toyonConfigSchema,
+    kind: _enum(["shared", "local"])
+  }),
   object({ t: literal("register-repo"), path: string2().min(1).max(4000) }),
   object({
     t: literal("create-repo"),
@@ -6393,6 +6510,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("exec"), worktreeId: id, command: shellCommand.min(1) }),
   object({ t: literal("exec-stop"), worktreeId: id }),
   object({ t: literal("search-refs"), repoId: id, query: string2().max(200) }),
+  object({ t: literal("search-chats"), repoId: id, query: string2().max(200) }),
   object({
     t: literal("open-ref"),
     clientId: string2().max(64).optional(),
@@ -7362,6 +7480,52 @@ function isDark(hex) {
   return luminance(hex) < 0.4;
 }
 
+// ../shared/src/update.ts
+function installMethod(packageJson) {
+  if (!packageJson)
+    return "none";
+  const p = packageJson.replaceAll("\\", "/");
+  if (p.includes("/_npx/"))
+    return "npx";
+  if (p.includes("/.bun/install/global/"))
+    return "bun";
+  if (p.includes("/node_modules/toyon/"))
+    return "npm";
+  return "none";
+}
+function installCommand(method, version) {
+  if (method === "npm")
+    return ["npm", "install", "-g", `toyon@${version}`];
+  if (method === "bun")
+    return ["bun", "add", "-g", `toyon@${version}`];
+  return null;
+}
+function newer(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb)
+    return false;
+  for (let i = 0;i < 3; i++) {
+    const x = pa.nums[i] ?? 0;
+    const y = pb.nums[i] ?? 0;
+    if (x !== y)
+      return x > y;
+  }
+  if (pa.pre === pb.pre)
+    return false;
+  if (pa.pre === null)
+    return true;
+  if (pb.pre === null)
+    return false;
+  return pa.pre > pb.pre;
+}
+function parseVersion(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(v.trim());
+  if (!m)
+    return null;
+  return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ?? null };
+}
+
 // ../shared/src/vscode-theme.ts
 var workbenchKeys = {
   surface0: ["editor.background"],
@@ -7538,27 +7702,10 @@ function pickSyntax(tokenColors) {
 function slug(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "theme";
 }
-
-// ../shared/src/worktree-caps.ts
-function isMain(wt) {
-  return wt.kind === "main";
-}
-function canRemove(wt) {
-  return wt.kind === "worktree";
-}
-function canRename(wt) {
-  return wt.kind === "worktree" && hasOwnBranch(wt);
-}
-function canLand(wt) {
-  return wt.kind === "worktree" && wt.from?.kind !== "pr";
-}
-function canGraft(wt) {
-  return wt.kind === "worktree";
-}
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.1.0",
+  version: "0.3.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -11885,6 +12032,7 @@ var EXT = {
 };
 var ID = /^[A-Za-z0-9_-]{1,64}$/;
 var FILE = /^\d{1,6}\.(png|jpg|gif|webp|txt)$/;
+var isAttachmentFile = (file) => FILE.test(file);
 function attachmentsDirFor(attachmentsDir, worktreeId) {
   return join(attachmentsDir, worktreeId);
 }
@@ -12478,8 +12626,10 @@ function makePaths(home = process.env.TOYON_HOME ?? join3(homedir(), ".toyon"))
   return {
     home,
     stateFile: join3(home, DAEMON_FILES.state),
+    draftsFile: join3(home, DAEMON_FILES.drafts),
     tokenFile: join3(home, DAEMON_FILES.token),
     pidFile: join3(home, DAEMON_FILES.pid),
+    logFile: join3(home, DAEMON_FILES.log),
     remoteFile: join3(home, DAEMON_FILES.remote),
     transcriptsDir: join3(home, "transcripts"),
     attachmentsDir: join3(home, "attachments"),
@@ -12506,11 +12656,17 @@ function ensureDirs(p) {
 // ../daemon/src/git/exclude.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { dirname } from "path";
-async function excludeFromGit(cwd, pattern) {
+async function excludeFile(cwd) {
   const r = await git(cwd, "rev-parse", "--path-format=absolute", "--git-path", "info/exclude");
-  if (!r.ok || !r.out)
-    return log.warn("git", `cannot locate info/exclude for ${cwd}: ${r.err}`);
-  const file = r.out;
+  if (r.ok && r.out)
+    return r.out;
+  log.warn("git", `cannot locate info/exclude for ${cwd}: ${r.err}`);
+  return null;
+}
+async function excludeFromGit(cwd, pattern) {
+  const file = await excludeFile(cwd);
+  if (!file)
+    return;
   const current = existsSync3(file) ? readFileSync3(file, "utf8") : "";
   if (current.split(`
 `).some((l) => l.trim() === pattern))
@@ -12521,6 +12677,18 @@ async function excludeFromGit(cwd, pattern) {
 ` : ""}${pattern}
 `);
 }
+async function unexcludeFromGit(cwd, pattern) {
+  const file = await excludeFile(cwd);
+  if (!file || !existsSync3(file))
+    return;
+  const lines = readFileSync3(file, "utf8").split(`
+`);
+  const kept = lines.filter((l) => l.trim() !== pattern);
+  if (kept.length === lines.length)
+    return;
+  writeFileSync(file, kept.join(`
+`));
+}
 
 // ../daemon/src/agent/bounds.ts
 import { existsSync as existsSync4, realpathSync } from "fs";
@@ -13013,7 +13181,7 @@ var SYSTEM_APPEND = [
   "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.",
   "`@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 be merged, and land.route (optional: "merge", "push" or "pr") says how the user lands work on main. A settings.local.json beside it (toyon.local.json at the root) holds one person's overrides and is never committed.`,
+  `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.`,
   "When you scaffold a project, write its .gitignore (dependencies, build output, local env files) before installing anything, so an install never leaves thousands of untracked files for the user to wade through or commit.",
   "When you scaffold a project or change how it installs or starts, finish by updating the settings file Toyon already reads, or writing .toyon/settings.json when there is none, so the preview can run it."
 ].join(" ");
@@ -13050,10 +13218,11 @@ function buildPrompt(text, context, prefix, attachments = []) {
   }
   for (const a of attachments)
     blocks.push(...attachmentBlocks(a));
-  if (!leads)
-    blocks.push(textBlock(prefix ? `${prefix}
+  const body = [prefix, text].filter(Boolean).join(`
 
-${text}` : text));
+`);
+  if (!leads && body)
+    blocks.push(textBlock(body));
   if (context && !leads)
     blocks.push(textBlock(context));
   return blocks;
@@ -13077,26 +13246,41 @@ ${a.text}
 }
 
 // ../daemon/src/agent/transcript.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
-import { appendFile, rename, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { appendFile } from "fs/promises";
 import { join as join6 } from "path";
-var MAX_ENTRIES = 4000;
-var KEEP_ENTRIES = 2000;
 function transcriptPathFor(transcriptsDir, worktreeId) {
   return join6(transcriptsDir, `${worktreeId}.jsonl`);
 }
-function cutPoint(entries) {
-  const from = Math.max(0, entries.length - KEEP_ENTRIES);
-  for (let i = from;i < entries.length; i++) {
-    const t = entries[i].event.type;
-    if (t === "user-message" || t === "turn-start")
-      return i;
+function coalesce(entries) {
+  const out = [];
+  for (const entry of entries) {
+    const last = out.at(-1);
+    const { event } = entry;
+    if ((event.type === "text-delta" || event.type === "thinking-delta") && last?.event.type === event.type) {
+      out[out.length - 1] = { seq: last.seq, event: { type: event.type, text: last.event.text + event.text } };
+    } else {
+      out.push(entry);
+    }
   }
-  return from;
+  return out;
 }
-function serialize(entries) {
-  return entries.map((e) => `${JSON.stringify(e)}
-`).join("");
+function parseTranscript(text, tag) {
+  const out = [];
+  let torn = 0;
+  for (const line of text.split(`
+`)) {
+    if (!line)
+      continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      torn++;
+    }
+  }
+  if (torn)
+    log.warn(tag, `transcript: skipped ${torn} unparsable line(s)`);
+  return out;
 }
 
 class Transcript {
@@ -13112,31 +13296,7 @@ class Transcript {
     this.seq = (this.entries.at(-1)?.seq ?? -1) + 1;
   }
   read() {
-    if (!existsSync7(this.path))
-      return [];
-    const out = [];
-    let torn = 0;
-    for (const line of readFileSync6(this.path, "utf8").split(`
-`)) {
-      if (!line)
-        continue;
-      try {
-        out.push(JSON.parse(line));
-      } catch {
-        torn++;
-      }
-    }
-    if (torn)
-      log.warn(this.tag, `transcript: skipped ${torn} unparsable line(s)`);
-    if (out.length > MAX_ENTRIES) {
-      const kept = out.slice(cutPoint(out));
-      const tmp = `${this.path}.tmp`;
-      writeFileSync4(tmp, serialize(kept));
-      renameSync2(tmp, this.path);
-      log.info(this.tag, `transcript: compacted ${out.length} entries to ${kept.length}`);
-      return kept;
-    }
-    return out;
+    return existsSync7(this.path) ? parseTranscript(readFileSync6(this.path, "utf8"), this.tag) : [];
   }
   append(event) {
     const entry = { seq: this.seq++, event };
@@ -13144,19 +13304,8 @@ class Transcript {
     const line = `${JSON.stringify(entry)}
 `;
     this.writes = this.writes.then(() => appendFile(this.path, line)).catch((e) => log.warn(this.tag, "transcript append failed", e));
-    if (this.entries.length > MAX_ENTRIES)
-      this.compact();
     return entry;
   }
-  compact() {
-    this.entries.splice(0, cutPoint(this.entries));
-    const snapshot = serialize(this.entries);
-    const tmp = `${this.path}.tmp`;
-    this.writes = this.writes.then(async () => {
-      await writeFile2(tmp, snapshot);
-      await rename(tmp, this.path);
-    }).catch((e) => log.warn(this.tag, "transcript compaction failed", e));
-  }
   flush() {
     return this.writes;
   }
@@ -13692,6 +13841,9 @@ class AcpSession {
   get queueLength() {
     return this.queue.length;
   }
+  get unsettled() {
+    return this.queue.length > 0 || this.steered.length > 0 || this.refused !== null || this.asks.size > 0;
+  }
   get queueItems() {
     return this.waiting().map((q) => q.text);
   }
@@ -13929,7 +14081,7 @@ class AcpSession {
   describe(e) {
     if (isAuthRequired(e))
       return this.conn?.spec.loginHint ?? this.d.spec().loginHint;
-    const message = e instanceof Error ? e.message : String(e);
+    const message = (e instanceof Error ? e.message : String(e)).replace(/^Internal error: /, "");
     return /connection closed/i.test(message) ? this.conn?.link.exitInfo() ?? message : message;
   }
   async record({ text, attachments }) {
@@ -14214,6 +14366,8 @@ class AcpSession {
   }
   askPermission(params) {
     const plan = params.toolCall.kind === "switch_mode";
+    if (plan)
+      this.d.onPlan?.();
     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) => ({
@@ -14611,24 +14765,31 @@ function setsGrant(line) {
 // ../daemon/src/runtime/proxy.ts
 var DIAL_TIMEOUT_MS = 5000;
 var frame = (ev) => typeof ev.data === "string" ? ev.data : new Uint8Array(ev.data);
+var VITE_PING = "text/x-vite-ping";
 function previewHandler(opts) {
   const hostPart = (t) => t.host.includes(":") ? `[${t.host}]` : t.host;
   return {
     async fetch(req, upgrade) {
       const url = new URL(req.url);
-      const target = opts.getTarget();
       if (url.pathname === "/__toyon/bridge.js") {
         return new Response(opts.bridgeScript(), {
           headers: { "content-type": "text/javascript", "cache-control": "no-store" }
         });
       }
+      const isUpgrade = req.headers.get("upgrade")?.toLowerCase() === "websocket";
+      const machine = isUpgrade || req.headers.get("accept") === VITE_PING;
+      if (!machine)
+        opts.onRequest?.();
+      let target = opts.getTarget();
+      if (target == null && !machine && opts.ready)
+        target = await opts.ready();
       if (target == null) {
         return new Response(waitingPage(), {
           status: 503,
           headers: { "content-type": "text/html; charset=utf-8", "retry-after": "2" }
         });
       }
-      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+      if (isUpgrade) {
         const proto = req.headers.get("sec-websocket-protocol") ?? undefined;
         const upstreamUrl = `ws://${hostPart(target)}:${target.port}${url.pathname}${url.search}`;
         const pending = [];
@@ -14982,6 +15143,8 @@ async function reachableHost(port) {
 var LOG_RING_SIZE = 500;
 var POLL_INTERVAL_MS = 500;
 var POLL_ATTEMPTS = 120;
+var FAST_POLL_MS = 100;
+var FAST_POLL_WINDOW_MS = 3000;
 var PROC_RING = 128 * 1024;
 var PROC_COLS = 120;
 var PROC_ROWS = 30;
@@ -14995,6 +15158,7 @@ class WorktreeProcs {
   opts;
   procs = new Map;
   stopped = false;
+  asleep = false;
   lines = [];
   constructor(worktreePath, onProc, onLog, onData = () => {}, onStreamExit = () => {}, opts = {}) {
     this.worktreePath = worktreePath;
@@ -15041,7 +15205,7 @@ class WorktreeProcs {
         cols: mp.pty?.cols ?? PROC_COLS,
         rows: mp.pty?.rows ?? PROC_ROWS,
         file: "sh",
-        args: ["-c", command],
+        args: ["-c", execForm(command)],
         ring: PROC_RING
       }, (data) => {
         this.onData(name, data);
@@ -15062,7 +15226,7 @@ class WorktreeProcs {
     const { name } = mp.state;
     mp.state.exitCode = code;
     this.onStreamExit(name, code);
-    if (this.stopped || mp.state.status === "stopped")
+    if (this.stopped || mp.state.status === "stopped" || mp.state.status === "asleep")
       return;
     if (mp.handInput) {
       mp.state.status = "stopped";
@@ -15088,8 +15252,9 @@ class WorktreeProcs {
     }
   }
   async pollPort(mp) {
-    const attempts = this.opts.pollAttempts ?? POLL_ATTEMPTS;
-    for (let i = 0;i < attempts; i++) {
+    const deadline = Date.now() + (this.opts.pollAttempts ?? POLL_ATTEMPTS) * POLL_INTERVAL_MS;
+    const started = Date.now();
+    while (Date.now() < deadline) {
       if (this.stopped || mp.state.status !== "starting")
         return;
       const host = await reachableHost(mp.state.port);
@@ -15099,7 +15264,7 @@ class WorktreeProcs {
         this.onProc({ ...mp.state });
         return;
       }
-      await Bun.sleep(POLL_INTERVAL_MS);
+      await Bun.sleep(Date.now() - started < FAST_POLL_WINDOW_MS ? FAST_POLL_MS : POLL_INTERVAL_MS);
     }
     await this.diagnose(mp);
   }
@@ -15146,7 +15311,7 @@ class WorktreeProcs {
   }
   restart(name) {
     const mp = this.procs.get(name);
-    if (!mp)
+    if (!mp || this.asleep)
       return;
     mp.restarts = 0;
     if (mp.state.status === "crashed") {
@@ -15162,6 +15327,35 @@ class WorktreeProcs {
   async killProc(mp) {
     await mp.pty?.kill();
   }
+  async sleep() {
+    if (this.asleep || this.stopped)
+      return;
+    this.asleep = true;
+    const exits = [];
+    for (const mp of this.procs.values()) {
+      mp.state.status = "asleep";
+      mp.state.pid = undefined;
+      this.onProc({ ...mp.state });
+      exits.push(this.killProc(mp));
+    }
+    await Promise.all(exits);
+  }
+  wake() {
+    if (!this.asleep || this.stopped)
+      return;
+    this.asleep = false;
+    for (const mp of this.procs.values()) {
+      mp.restarts = 0;
+      this.spawnProc(mp);
+    }
+  }
+  pgids() {
+    const out = [];
+    for (const mp of this.procs.values())
+      if (mp.pty?.alive)
+        out.push(mp.pty.pid);
+    return out;
+  }
   async stopAll() {
     this.stopped = true;
     const exits = [];
@@ -15185,6 +15379,12 @@ class WorktreeProcs {
     this.onLog(proc, line);
   }
 }
+function execForm(command) {
+  const trimmed = command.trim();
+  if (/[;&|<>()`\n]|\$\(/.test(trimmed) || /^[A-Za-z_][A-Za-z0-9_]*=/.test(trimmed))
+    return command;
+  return `exec ${trimmed}`;
+}
 function envStrings(base) {
   const env = {};
   for (const [k, v] of Object.entries(base))
@@ -15222,6 +15422,8 @@ function terminalEnv(base, own, urls) {
   return { ...env, ...urls, TERM: "xterm-256color", COLORTERM: "truecolor", ...own };
 }
 var DEFAULT_AGENT_ID = "claude";
+var PREVIEW_WAKE_MS = 8000;
+var PREVIEW_POLL_MS = 100;
 function defaultAgent(wt, d) {
   const agent = new AcpSession({
     worktreeId: wt.id,
@@ -15255,6 +15457,13 @@ function defaultAgent(wt, d) {
       d.state.save();
       d.hub.emit("worktreesChanged");
     },
+    onPlan: () => {
+      const w = d.state.worktree(wt.id);
+      if (!w || w.planned)
+        return;
+      w.planned = true;
+      d.state.save();
+    },
     option: (category) => d.state.requireWorktree(wt.id)[OPTION_FIELDS[category]],
     onOptionsLearned: (category, choices) => {
       const agentId = d.state.requireWorktree(wt.id).agent ?? "";
@@ -15272,19 +15481,24 @@ function defaultProcs(wt, d) {
 function defaultTerminal(_wt, opts, onData, onExit) {
   return new PtyStream(opts, onData, onExit);
 }
-function defaultProxy(wt, previewName, procs, d) {
+function defaultProxy(wt, previewName, procs, d, wake) {
   return startProxy({
     port: wt.proxyPort,
     hostname: cloud.bindHost,
     remote: d.remote ?? null,
     grant: d.grant ?? "",
     bridgeScript: d.bridgeScript,
-    getTarget: () => previewTargetOf(procs, previewName)
+    getTarget: () => previewTargetOf(procs, previewName),
+    onRequest: wake.onRequest,
+    ready: wake.ready
   });
 }
+function previewProcOf(procs, previewName) {
+  return procs.states().find((p) => p.name === previewName) ?? procs.states()[0];
+}
 function previewTargetOf(procs, previewName) {
-  const st = procs.states().find((p) => p.name === previewName) ?? procs.states()[0];
-  if (!st || st.status === "crashed" || st.status === "unreachable")
+  const st = previewProcOf(procs, previewName);
+  if (st?.status !== "running")
     return null;
   return { port: st.boundPort ?? st.port, host: st.host ?? "127.0.0.1" };
 }
@@ -15293,9 +15507,118 @@ class RuntimeRegistry {
   deps;
   runtimes = new Map;
   looseShells = new Map;
+  holds = new Map;
+  settingUp = new Set;
+  starting = new Set;
   constructor(deps) {
     this.deps = deps;
   }
+  hold(id, tag) {
+    let tags = this.holds.get(id);
+    if (!tags) {
+      tags = new Set;
+      this.holds.set(id, tags);
+    }
+    tags.add(tag);
+    this.deps.hub.emit("holdsChanged", id, tags.size);
+  }
+  release(id, tag) {
+    const tags = this.holds.get(id);
+    if (!tags?.delete(tag))
+      return;
+    if (tags.size === 0)
+      this.holds.delete(id);
+    this.deps.hub.emit("holdsChanged", id, tags.size);
+  }
+  holdCount(id) {
+    return this.holds.get(id)?.size ?? 0;
+  }
+  busy(id) {
+    const agent = this.agentFor(id);
+    if (agent && (agent.status !== "idle" || agent.unsettled))
+      return true;
+    return this.holdCount(id) > 0;
+  }
+  anyBusy() {
+    for (const id of this.runtimes.keys())
+      if (this.busy(id))
+        return true;
+    for (const id of this.holds.keys())
+      if (this.busy(id))
+        return true;
+    return false;
+  }
+  markSetup(id, on) {
+    if (on)
+      this.settingUp.add(id);
+    else
+      this.settingUp.delete(id);
+  }
+  async wake(id) {
+    const wt = this.deps.state.worktree(id);
+    if (!wt)
+      return;
+    const rt = this.runtimes.get(id);
+    if (rt?.procs) {
+      if (!rt.procs.asleep)
+        return;
+      rt.procs.wake();
+      log.info(id, "awake");
+      this.deps.hub.emit("worktreesChanged");
+      return;
+    }
+    if (this.settingUp.has(id))
+      return;
+    const repo = this.deps.state.repos.find((r) => r.id === wt.repoId);
+    if (repo)
+      await this.start(wt, repo);
+  }
+  async sleep(id) {
+    const rt = this.runtimes.get(id);
+    if (!rt?.procs || rt.procs.asleep)
+      return;
+    await rt.procs.sleep();
+    this.deps.hub.emit("worktreesChanged");
+  }
+  async awaitPreview(id, ms) {
+    const deadline = Date.now() + ms;
+    for (;; ) {
+      const rt = this.runtimes.get(id);
+      if (!rt?.procs)
+        return null;
+      const st = previewProcOf(rt.procs, rt.previewName);
+      if (st?.status === "running")
+        return previewTargetOf(rt.procs, rt.previewName);
+      const coming = st ? st.status === "starting" : this.starting.has(id);
+      if (!coming || Date.now() >= deadline)
+        return null;
+      await Bun.sleep(PREVIEW_POLL_MS);
+    }
+  }
+  tiers() {
+    let awake = 0;
+    let asleep = 0;
+    for (const rt of this.runtimes.values()) {
+      if (!rt.procs)
+        continue;
+      if (rt.procs.asleep)
+        asleep++;
+      else
+        awake++;
+    }
+    return { awake, asleep };
+  }
+  awake() {
+    const out = [];
+    for (const [id, rt] of this.runtimes) {
+      if (rt.procs && !rt.procs.asleep)
+        out.push({ id, pgids: rt.procs.pgids() });
+    }
+    return out;
+  }
+  isAsleep(id) {
+    return this.runtimes.get(id)?.procs?.asleep ?? false;
+  }
   openLooseShell(id, cwd, cols, rows) {
     let term = this.looseShells.get(id);
     if (!term?.alive) {
@@ -15380,19 +15703,30 @@ class RuntimeRegistry {
       const urls = { ...procUrlEnv(procs.states(), previewName), ...worktreeEnv(wt, repo) };
       return { ...urls, ...expandEnv(run.env, urls) };
     };
-    for (const [name, cmd] of Object.entries(run.procs)) {
-      if (name !== previewName)
-        await procs.start(name, cmd, envFor());
-    }
-    if (previewName && run.procs[previewName]) {
-      await procs.start(previewName, run.procs[previewName], envFor());
+    this.starting.add(wt.id);
+    try {
+      for (const [name, cmd] of Object.entries(run.procs)) {
+        if (name !== previewName)
+          await procs.start(name, cmd, envFor());
+      }
+      if (previewName && run.procs[previewName]) {
+        await procs.start(previewName, run.procs[previewName], envFor());
+      }
+    } finally {
+      this.starting.delete(wt.id);
     }
     if (!this.deps.state.worktree(wt.id) || this.runtimes.get(wt.id) !== rt) {
       this.returnLease(wt.id);
       await procs.stopAll();
       return;
     }
-    rt.proxy = (this.deps.makeProxy ?? defaultProxy)(live, previewName, procs, this.deps);
+    rt.proxy = (this.deps.makeProxy ?? defaultProxy)(live, previewName, procs, this.deps, {
+      onRequest: () => {
+        this.deps.hub.emit("previewRequest", wt.id);
+        fireAndForget(wt.id, this.wake(wt.id), "wake on request");
+      },
+      ready: () => this.awaitPreview(wt.id, PREVIEW_WAKE_MS)
+    });
     this.deps.hub.emit("worktreesChanged");
   }
   leased = new Map;
@@ -15415,6 +15749,8 @@ class RuntimeRegistry {
     await procs?.stopAll();
   }
   async stop(id) {
+    this.holds.delete(id);
+    this.settingUp.delete(id);
     const rt = this.runtimes.get(id);
     if (!rt)
       return;
@@ -15537,6 +15873,8 @@ class RuntimeRegistry {
         this.startLogin(id, rt.login.run);
     } else if (stream === SHELL_STREAM)
       await rt?.shell?.kill();
+    else if (rt?.procs?.asleep)
+      await this.wake(id);
     else
       rt?.procs?.restart(stream);
   }
@@ -15545,11 +15883,7 @@ class RuntimeRegistry {
   }
   previewTarget(id) {
     const rt = this.runtimes.get(id);
-    if (!rt?.procs)
-      return null;
-    const t = previewTargetOf(rt.procs, rt.previewName);
-    const st = rt.procs.states().find((p) => p.port === t?.port);
-    return st?.status === "running" ? t : null;
+    return rt?.procs ? previewTargetOf(rt.procs, rt.previewName) : null;
   }
   async shutdown() {
     this.pruneLooseShells(new Set);
@@ -15859,6 +16193,20 @@ var NAME_SYSTEM = "You are a naming assistant. Reply with only the requested nam
 var namePrompt = (task) => `Name this coding task in 2 to 4 lowercase kebab-case words (like "sticky-header" or "dark-mode-toggle"). Reply with ONLY the name, nothing else.
 
 Task: ${task.slice(0, 500)}`;
+function taskText(text, attachments = []) {
+  if (text.trim())
+    return text;
+  return attachments.map(attachmentText).join(`
+
+`);
+}
+function attachmentText(a) {
+  if (a.kind === "paste")
+    return a.text;
+  if (a.kind === "image")
+    return a.name ? `image ${a.name}` : "an image";
+  return `element <${a.component ?? a.tag}>${a.text ? ` "${a.text}"` : ""}`;
+}
 function parseName(text) {
   if (!text)
     return null;
@@ -15932,15 +16280,47 @@ function makePlanner(agents) {
 }
 
 // ../daemon/src/core/assets.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync2, rmSync, statSync as statSync2 } from "fs";
+import { join as join7, resolve as resolve5 } from "path";
 function locateAssets(here, env = process.env) {
   const packaged = existsSync9(join7(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"))
+    bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join7(here, "bridge.js") : join7(here, "../../bridge/dist/bridge.js")),
+    sourceRoot: packaged ? null : resolve5(here, "../../.."),
+    packageJson: packaged ? join7(here, "..", "package.json") : null
   };
 }
+var KEEP_MS = 3 * 24 * 60 * 60 * 1000;
+function pruneAssets(shellDist) {
+  const dir = join7(shellDist, "assets");
+  let names;
+  try {
+    names = readdirSync2(dir);
+  } catch {
+    return 0;
+  }
+  const found = [];
+  for (const name of names) {
+    const path = join7(dir, name);
+    try {
+      found.push({ path, mtime: statSync2(path).mtimeMs });
+    } catch {}
+  }
+  if (found.length === 0)
+    return 0;
+  const newest = Math.max(...found.map((f) => f.mtime));
+  let gone = 0;
+  for (const f of found) {
+    if (newest - f.mtime <= KEEP_MS)
+      continue;
+    try {
+      rmSync(f.path, { recursive: true, force: true });
+      gone++;
+    } catch {}
+  }
+  return gone;
+}
 
 // ../daemon/src/core/dialog.ts
 import { existsSync as existsSync10 } from "fs";
@@ -16030,38 +16410,181 @@ class Hub {
   }
 }
 
-// ../daemon/src/core/state.ts
-import { randomBytes } from "crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync8, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
-var SEEN_WORKTREES = 50;
-var empty = { repos: [], worktrees: [], sessions: {} };
-function loadState(paths) {
-  ensureDirs(paths);
-  const STATE_FILE = paths.stateFile;
-  if (!existsSync11(STATE_FILE))
-    return structuredClone(empty);
-  let raw;
-  try {
-    raw = readFileSync8(STATE_FILE, "utf8");
-  } catch (e) {
-    log.error("state", `cannot read ${STATE_FILE}; starting empty`, e);
-    return structuredClone(empty);
-  }
-  let state;
-  try {
-    state = { ...structuredClone(empty), ...JSON.parse(raw) };
-  } catch (e) {
-    const backup = `${STATE_FILE}.corrupt-${Date.now()}`;
-    try {
-      writeFileSync5(backup, raw);
-    } catch (be) {
-      log.warn("state", "could not write the corrupt-state backup", be);
-    }
-    log.error("state", `${STATE_FILE} is not valid JSON; copied to ${backup} and starting empty`, e);
-    return structuredClone(empty);
+// ../daemon/src/core/restart.ts
+import { spawn as spawn2 } from "child_process";
+import { openSync } from "fs";
+function restartable(env = process.env) {
+  if (env.TOYON_WORKTREE !== undefined) {
+    return { ok: false, reason: "this daemon runs as a toyon process; restart it from its terminal tab" };
   }
-  const ids = new Set(state.worktrees.map((w) => w.id));
-  for (const id of Object.keys(state.sessions))
+  return { ok: true };
+}
+function respawn(logFile) {
+  const logFd = openSync(logFile, "a");
+  const child = spawn2(process.execPath, process.argv.slice(1), {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.on("error", (e) => log.warn("daemon", `the replacement did not start: ${e.message}`));
+  child.unref();
+}
+
+// ../daemon/src/core/restarter.ts
+class Restarter {
+  d;
+  asked = false;
+  gone = false;
+  announced = null;
+  constructor(d) {
+    this.d = d;
+    const settle = () => {
+      if (this.asked)
+        this.attempt();
+    };
+    d.hub.on("agentStatus", settle);
+    d.hub.on("worktreesChanged", settle);
+  }
+  request() {
+    const refused = this.d.refusal();
+    if (refused)
+      return refused;
+    this.asked = true;
+    this.attempt();
+    return null;
+  }
+  waitingOn() {
+    if (!this.asked)
+      return null;
+    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);
+  }
+  attempt() {
+    if (this.gone)
+      return;
+    const names = this.working();
+    if (names.length === 0)
+      this.gone = true;
+    const key = JSON.stringify(this.waitingOn());
+    if (key !== this.announced) {
+      this.announced = key;
+      this.d.hub.emit("updateChanged");
+    }
+    if (this.gone)
+      this.d.go();
+  }
+}
+
+// ../daemon/src/core/self.ts
+function needsRestart(path) {
+  return path.startsWith("packages/daemon/") || path.startsWith("packages/shared/") || path === "package.json" || path === "bun.lock";
+}
+function needsRebuild(path) {
+  return path.startsWith("packages/shell/") || path.startsWith("packages/bridge/") || path.startsWith("packages/shared/");
+}
+function classify(paths) {
+  let rebuild = false;
+  let restart = false;
+  for (const path of paths) {
+    if (needsRebuild(path))
+      rebuild = true;
+    if (needsRestart(path))
+      restart = true;
+  }
+  return { rebuild, restart };
+}
+
+class SelfWatch {
+  root;
+  booted = null;
+  state = null;
+  constructor(root) {
+    this.root = root;
+  }
+  async start() {
+    if (!this.root)
+      return;
+    const head = await git(this.root, "rev-parse", "HEAD");
+    if (!head.ok) {
+      log.debug("self", `no HEAD in ${this.root}; not watching it`);
+      return;
+    }
+    this.booted = head.out.trim();
+  }
+  own(repo) {
+    return this.root !== null && repo.path === this.root;
+  }
+  async check(repo) {
+    if (this.booted === null || !this.own(repo))
+      return false;
+    const names = await git(this.root ?? "", "diff", "--name-only", `${this.booted}..${repo.defaultBranch}`);
+    if (!names.ok) {
+      log.debug("self", `could not diff ${this.booted}..${repo.defaultBranch}: ${names.err}`);
+      return false;
+    }
+    const paths = names.out.split(`
+`).filter((l) => l !== "");
+    const { rebuild, restart } = classify(paths);
+    return this.set({ repoId: repo.id, rebuild, restart, building: this.state?.building ?? false });
+  }
+  building(on, failure) {
+    if (!this.state)
+      return false;
+    const done = !on && failure === undefined;
+    return this.set({
+      ...this.state,
+      building: on,
+      rebuild: done ? false : this.state.rebuild,
+      buildFailed: on ? undefined : failure
+    });
+  }
+  get() {
+    return this.state;
+  }
+  set(next) {
+    const quiet = !next.rebuild && !next.restart && !next.building && next.buildFailed === undefined;
+    const value = quiet ? null : next;
+    if (JSON.stringify(value) === JSON.stringify(this.state))
+      return false;
+    this.state = value;
+    return true;
+  }
+}
+
+// ../daemon/src/core/state.ts
+import { randomBytes } from "crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
+var SEEN_WORKTREES = 50;
+var empty = { repos: [], worktrees: [], sessions: {} };
+function loadState(paths) {
+  ensureDirs(paths);
+  const STATE_FILE = paths.stateFile;
+  if (!existsSync11(STATE_FILE))
+    return structuredClone(empty);
+  let raw;
+  try {
+    raw = readFileSync8(STATE_FILE, "utf8");
+  } catch (e) {
+    log.error("state", `cannot read ${STATE_FILE}; starting empty`, e);
+    return structuredClone(empty);
+  }
+  let state;
+  try {
+    state = { ...structuredClone(empty), ...JSON.parse(raw) };
+  } catch (e) {
+    const backup = `${STATE_FILE}.corrupt-${Date.now()}`;
+    try {
+      writeFileSync4(backup, raw);
+    } catch (be) {
+      log.warn("state", "could not write the corrupt-state backup", be);
+    }
+    log.error("state", `${STATE_FILE} is not valid JSON; copied to ${backup} and starting empty`, e);
+    return structuredClone(empty);
+  }
+  const ids = new Set(state.worktrees.map((w) => w.id));
+  for (const id of Object.keys(state.sessions))
     if (!ids.has(id))
       delete state.sessions[id];
   for (const id of Object.keys(state.seen ?? {})) {
@@ -16080,8 +16603,8 @@ function loadState(paths) {
 }
 function saveState(paths, state) {
   const tmp = `${paths.stateFile}.tmp`;
-  writeFileSync5(tmp, JSON.stringify(state, null, 2));
-  renameSync3(tmp, paths.stateFile);
+  writeFileSync4(tmp, JSON.stringify(state, null, 2));
+  renameSync2(tmp, paths.stateFile);
 }
 function loadOrCreateToken(paths) {
   ensureDirs(paths);
@@ -16089,7 +16612,7 @@ function loadOrCreateToken(paths) {
   if (existsSync11(TOKEN_FILE))
     return readFileSync8(TOKEN_FILE, "utf8").trim();
   const token = randomBytes(32).toString("hex");
-  writeFileSync5(TOKEN_FILE, token, { mode: 384 });
+  writeFileSync4(TOKEN_FILE, token, { mode: 384 });
   return token;
 }
 
@@ -16221,6 +16744,13 @@ class StateStore {
     this.state.theme = prefs;
     this.save();
   }
+  get updateFailed() {
+    return this.state.updateFailed;
+  }
+  setUpdateFailed(failed) {
+    this.state.updateFailed = failed;
+    this.save();
+  }
   save() {
     saveState(this.paths, this.state);
   }
@@ -16798,6 +17328,87 @@ async function loadProjectTypescript(root) {
   }
 }
 
+// ../daemon/src/drafts/store.ts
+import { existsSync as existsSync12, readFileSync as readFileSync9, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
+var SAVE_DELAY_MS = 1000;
+
+class DraftStore {
+  d;
+  drafts = {};
+  saveTimer = null;
+  constructor(d) {
+    this.d = d;
+    if (!existsSync12(d.file))
+      return;
+    try {
+      const raw = JSON.parse(readFileSync9(d.file, "utf8"));
+      if (!raw || typeof raw !== "object")
+        return;
+      for (const [id, text] of Object.entries(raw)) {
+        if (typeof text === "string" && text)
+          this.drafts[id] = text;
+      }
+    } catch (e) {
+      log.warn("drafts", `skipped an unreadable ${d.file}`, e);
+    }
+  }
+  all() {
+    return { ...this.drafts };
+  }
+  has(boxId) {
+    return !!this.drafts[boxId]?.trim();
+  }
+  set(boxId, text, clientId) {
+    if ((this.drafts[boxId] ?? "") === text)
+      return;
+    if (text)
+      this.drafts[boxId] = text;
+    else
+      delete this.drafts[boxId];
+    this.scheduleSave();
+    this.d.hub.emit("draftChanged", boxId, text, clientId);
+  }
+  drop(boxId) {
+    this.set(boxId, "");
+  }
+  prune(known) {
+    let changed = false;
+    for (const id of Object.keys(this.drafts)) {
+      if (known(id))
+        continue;
+      delete this.drafts[id];
+      changed = true;
+    }
+    if (changed)
+      this.scheduleSave();
+  }
+  flush() {
+    if (!this.saveTimer)
+      return;
+    clearTimeout(this.saveTimer);
+    this.saveTimer = null;
+    this.write();
+  }
+  scheduleSave() {
+    if (this.saveTimer)
+      return;
+    this.saveTimer = setTimeout(() => {
+      this.saveTimer = null;
+      this.write();
+    }, this.d.saveDelayMs ?? SAVE_DELAY_MS);
+    this.saveTimer.unref?.();
+  }
+  write() {
+    const tmp = `${this.d.file}.tmp`;
+    try {
+      writeFileSync5(tmp, JSON.stringify(this.drafts));
+      renameSync3(tmp, this.d.file);
+    } catch (e) {
+      log.error("drafts", "could not write the drafts", e);
+    }
+  }
+}
+
 // ../daemon/src/exec/service.ts
 var OUTPUT_CAP = 200000;
 var TIMEOUT_MS = 10 * 60000;
@@ -16841,6 +17452,7 @@ class ExecService {
     }
     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);
   }
   stop(worktreeId) {
@@ -16906,6 +17518,7 @@ class ExecService {
       const r = this.untrack(worktreeId, toolId);
       if (r)
         clearTimeout(r.timer);
+      this.deps.runtime.release(worktreeId, `exec:${toolId}`);
     }
     agent.note({ type: "tool-end", toolId, output: formatOutput(text, exit, truncated), isError: exit !== 0 });
     return { exit, text };
@@ -16931,7 +17544,7 @@ ${body}
 }
 
 // ../daemon/src/files/service.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { stat, unlink } from "fs/promises";
 
 // ../daemon/src/git/lock.ts
@@ -17047,10 +17660,13 @@ async function committedFiles(worktreePath, defaultBr) {
   const base = await git(worktreePath, "merge-base", "HEAD", defaultBr);
   if (!base.ok || !base.out)
     return [];
-  const r = await git(worktreePath, "diff", "--name-status", base.out, "HEAD");
+  return filesBetween(worktreePath, base.out, "HEAD");
+}
+async function filesBetween(cwd, from, to) {
+  const r = await git(cwd, "diff", "--name-status", from, to);
   if (!r.ok || !r.out)
     return [];
-  const counts = await numstat(worktreePath, base.out, "HEAD");
+  const counts = await numstat(cwd, from, to);
   return r.out.split(`
 `).filter(Boolean).map((line) => {
     const [status, ...rest] = line.split("\t");
@@ -17080,6 +17696,9 @@ async function treeEmpty(worktreePath) {
   const r = await git(worktreePath, "ls-tree", "--name-only", "HEAD");
   return !r.ok || r.out === "";
 }
+async function isTracked(worktreePath, rel) {
+  return (await git(worktreePath, "ls-files", "--error-unmatch", "--", rel)).ok;
+}
 async function behindUpstream(worktreePath) {
   const r = await git(worktreePath, "rev-list", "--count", "HEAD..@{upstream}");
   return r.ok ? Number(r.out) || 0 : null;
@@ -17100,10 +17719,15 @@ async function logCommits(worktreePath, defaultBr, limit = LOG_LIMIT) {
     git(worktreePath, "log", `-n${limit}`, FORMAT),
     aheadShas(worktreePath, defaultBr)
   ]);
-  if (!r.ok || !r.out)
-    return [];
+  return r.ok && r.out ? parseLog(r.out, (sha) => ahead.has(sha)) : [];
+}
+async function logRange(cwd, from, to, limit = LOG_LIMIT) {
+  const r = await git(cwd, "log", `-n${limit}`, FORMAT, `${from}..${to}`);
+  return r.ok && r.out ? parseLog(r.out, () => true) : [];
+}
+function parseLog(out, ahead) {
   const commits = [];
-  for (const rec of r.out.split("\x1E")) {
+  for (const rec of out.split("\x1E")) {
     const [sha, short, author, at, subject] = rec.trim().split("\x00");
     if (!sha || !short || subject === undefined)
       continue;
@@ -17113,7 +17737,7 @@ async function logCommits(worktreePath, defaultBr, limit = LOG_LIMIT) {
       subject,
       author: author ?? "",
       at: Number(at) * 1000 || 0,
-      ahead: ahead.has(sha)
+      ahead: ahead(sha)
     });
   }
   return commits;
@@ -17149,12 +17773,12 @@ async function fileAtCommit(worktreePath, sha, file) {
 }
 
 // ../daemon/src/worktrees/paths.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 function resolveInside(worktreePath, rel, opts = {}) {
   if (typeof rel !== "string" || rel.includes("\x00"))
     throw new UserError("invalid path");
-  const root = canonical(resolve5(worktreePath));
-  const target = canonical(resolve5(worktreePath, rel));
+  const root = canonical(resolve6(worktreePath));
+  const target = canonical(resolve6(worktreePath, rel));
   if (target === root) {
     if (opts.allowRoot)
       return target;
@@ -17294,6 +17918,30 @@ 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) {
+  const gone = new Set(entries(deleted));
+  const paths = new Set;
+  const submodules = new Set;
+  for (const line of entries(staged)) {
+    const tab = line.indexOf("\t");
+    if (tab === -1)
+      continue;
+    const path = line.slice(tab + 1);
+    if (gone.has(path))
+      continue;
+    if (line.startsWith(SUBMODULE_MODE))
+      submodules.add(path);
+    else
+      paths.add(path);
+  }
+  for (const path of entries(untracked))
+    paths.add(path);
+  return { paths: [...paths], submodules: [...submodules] };
+}
+
 // ../daemon/src/files/vite-offset.ts
 async function viteLineOffset(worktreePath, path, target) {
   if (!target)
@@ -17374,6 +18022,9 @@ function sides(before, after) {
   }
   return { before, after, binary: false, tooLarge: false };
 }
+function keptRead(before, after) {
+  return { ...sides(before, after), version: null, writable: false };
+}
 
 class FileService {
   state;
@@ -17452,9 +18103,13 @@ class FileService {
     });
   }
   async list(worktreeId) {
-    const r = await git(this.require(worktreeId).path, "ls-files", "-co", "--exclude-standard");
-    return r.out.split(`
-`).filter(Boolean);
+    const cwd = this.require(worktreeId).path;
+    const [staged, untracked, deleted] = await Promise.all([
+      git(cwd, "ls-files", "-z", "-s"),
+      git(cwd, "ls-files", "-z", "-o", "--exclude-standard"),
+      git(cwd, "ls-files", "-z", "-d")
+    ]);
+    return parseListing(staged.out, untracked.out, deleted.out);
   }
   async search(worktreeId, query) {
     const { path: cwd } = this.require(worktreeId);
@@ -17521,7 +18176,7 @@ class FileService {
   revealPath(target) {
     if (process.platform !== "darwin")
       throw new UserError("reveal is only available on macOS");
-    const child = spawn2("open", ["-R", target], { stdio: "ignore" });
+    const child = spawn3("open", ["-R", target], { stdio: "ignore" });
     child.on("error", () => {});
     child.unref();
   }
@@ -17614,8 +18269,89 @@ function prNumberOf(url) {
   return m ? Number(m[1]) : null;
 }
 
+// ../daemon/src/runtime/setup.ts
+var SETUP_RING = 64 * 1024;
+var SETUP_COLS = 120;
+var SETUP_ROWS = 30;
+function runSetup(cmd, cwd, onLine, extra = {}) {
+  return new Promise((resolve) => {
+    const lines = new LineSplitter;
+    try {
+      new PtyStream({
+        cwd,
+        env: { ...envStrings2(process.env), TERM: "xterm-256color", COLORTERM: "truecolor", ...extra },
+        cols: SETUP_COLS,
+        rows: SETUP_ROWS,
+        file: "sh",
+        args: ["-c", cmd],
+        ring: SETUP_RING
+      }, (data) => {
+        for (const line of lines.feed(data))
+          onLine(line);
+      }, resolve);
+    } catch (e) {
+      onLine(`could not run: ${e instanceof Error ? e.message : String(e)}`);
+      resolve(1);
+    }
+  });
+}
+function envStrings2(base) {
+  const env = {};
+  for (const [k, v] of Object.entries(base))
+    if (typeof v === "string")
+      env[k] = v;
+  return env;
+}
+
+// ../daemon/src/repos/afterLand.ts
+class AfterLand {
+  d;
+  running = new Set;
+  constructor(d) {
+    this.d = d;
+  }
+  busy(repoId) {
+    return this.running.has(repoId);
+  }
+  run(repoId) {
+    const repo = this.d.state.repo(repoId);
+    const commands = repo?.config.afterLand ?? [];
+    if (!repo || commands.length === 0 || this.running.has(repoId))
+      return;
+    this.running.add(repoId);
+    const done = this.exec(repo, commands).finally(() => this.running.delete(repoId));
+    fireAndForget(repo.id, done, "afterLand");
+  }
+  async exec(repo, commands) {
+    if (this.d.self.building(true))
+      this.d.hub.emit("selfChanged");
+    let failure;
+    for (const command of commands) {
+      this.tellMain(repo, `afterLand: ${command}`);
+      let last = "";
+      const code = await runSetup(command, repo.path, (line) => {
+        last = line;
+        this.tellMain(repo, line);
+      });
+      if (code === 0)
+        continue;
+      failure = last.trim() === "" ? `${command} (exit ${code})` : last.trim();
+      this.tellMain(repo, `afterLand stopped: ${command} exited ${code}`);
+      log.warn(repo.id, `afterLand stopped: ${command} exited ${code}`);
+      break;
+    }
+    if (this.d.self.building(false, failure))
+      this.d.hub.emit("selfChanged");
+  }
+  tellMain(repo, line) {
+    const main = this.d.state.worktrees.find((w) => w.repoId === repo.id && w.kind === "main");
+    if (main)
+      this.d.hub.emit("log", main.id, "land", line);
+  }
+}
+
 // ../daemon/src/repos/registry.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync5, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir7 } from "os";
 import { basename as basename3, dirname as dirname6, join as join14 } from "path";
 
@@ -17643,11 +18379,11 @@ function variantLens(index) {
 }
 
 // ../daemon/src/repos/browse.ts
-import { existsSync as existsSync12, statSync as statSync2 } from "fs";
+import { existsSync as existsSync13, 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";
-var MAX_ENTRIES2 = 40;
+var MAX_ENTRIES = 40;
 function expandTilde(raw) {
   return raw === "~" || raw.startsWith("~/") ? join10(homedir5(), raw.slice(1)) : raw;
 }
@@ -17660,7 +18396,7 @@ function holdsNothing(names) {
 }
 async function describeFolder(abs) {
   const path = collapseTilde(abs);
-  if (existsSync12(join10(abs, ".git")))
+  if (existsSync13(join10(abs, ".git")))
     return { path, kind: "project" };
   try {
     return { path, kind: holdsNothing(await readdir(abs)) ? "empty" : "folder" };
@@ -17672,13 +18408,13 @@ var NOWHERE = { exists: false, isDir: false, isRepo: false, parentExists: false
 function describe2(typed, parent) {
   let isDir = false;
   try {
-    isDir = statSync2(typed).isDirectory();
+    isDir = statSync3(typed).isDirectory();
   } catch {}
   return {
-    exists: existsSync12(typed),
+    exists: existsSync13(typed),
     isDir,
-    isRepo: isDir && existsSync12(join10(typed, ".git")),
-    parentExists: existsSync12(parent)
+    isRepo: isDir && existsSync13(join10(typed, ".git")),
+    parentExists: existsSync13(parent)
   };
 }
 async function browsePath(raw) {
@@ -17703,17 +18439,17 @@ async function browsePath(raw) {
     if (!name.toLowerCase().startsWith(prefix))
       continue;
     const abs = join10(dir, name);
-    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync12(join10(abs, ".git")) });
+    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync13(join10(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_ENTRIES2), target };
+  return { entries: entries.slice(0, MAX_ENTRIES), target };
 }
 
 // ../daemon/src/repos/config.ts
-import { closeSync, existsSync as existsSync13, openSync, readdirSync as readdirSync2, readFileSync as readFileSync9, readSync } from "fs";
+import { closeSync, existsSync as existsSync14, openSync as openSync2, readdirSync as readdirSync3, readFileSync as readFileSync10, readSync } from "fs";
 import { join as join11 } from "path";
 var PLACES = [CONFIG_FILES.folder, CONFIG_FILES.root];
-var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync13(join11(repoPath, rel)));
+var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync14(join11(repoPath, rel)));
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function readConfigFile(repoPath) {
   const found = PLACES.map((p) => present(repoPath, p)).filter((files) => files.length > 0);
@@ -17728,7 +18464,7 @@ function readConfigFile(repoPath) {
   for (const rel of files) {
     let raw;
     try {
-      raw = JSON.parse(readFileSync9(join11(repoPath, rel), "utf8"));
+      raw = JSON.parse(readFileSync10(join11(repoPath, rel), "utf8"));
     } catch (e) {
       return { ok: false, reason: `${rel} is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
     }
@@ -17786,11 +18522,11 @@ 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 || !existsSync13(abs))
+  if (!abs || !existsSync14(abs))
     return config;
   let shared;
   try {
-    shared = JSON.parse(readFileSync9(abs, "utf8"));
+    shared = JSON.parse(readFileSync10(abs, "utf8"));
   } catch {
     return config;
   }
@@ -17803,8 +18539,8 @@ function detectConfig(repoPath) {
   if (explicit)
     log.warn("config", `${repoPath}: ${explicit.reason}; detecting instead`);
   const pkgPath = join11(repoPath, "package.json");
-  if (existsSync13(pkgPath)) {
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+  if (existsSync14(pkgPath)) {
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
     const runner = detectRunner(repoPath, pkg.packageManager);
     const pages = detectPages(repoPath, scripts, runner);
@@ -17825,7 +18561,7 @@ function detectConfig(repoPath) {
       };
     }
   }
-  if (existsSync13(join11(repoPath, "start.sh"))) {
+  if (existsSync14(join11(repoPath, "start.sh"))) {
     return { config: { run: { app: "./start.sh" } }, needsSetup: true, from: "start.sh" };
   }
   const assumed = assumeNothingToRun(repoPath);
@@ -17868,19 +18604,19 @@ function assumeNothingToRun(repoPath) {
   return marker && !servesPage(repoPath) ? marker : undefined;
 }
 function markerIn(repoPath) {
-  const named = NO_PAGE_MARKERS.find((f) => existsSync13(join11(repoPath, f)));
+  const named = NO_PAGE_MARKERS.find((f) => existsSync14(join11(repoPath, f)));
   if (named)
     return named;
   let entries;
   try {
-    entries = readdirSync2(repoPath);
+    entries = readdirSync3(repoPath);
   } catch {
     return;
   }
   return entries.find((f) => NO_PAGE_EXTENSIONS.some((ext) => f.endsWith(ext)));
 }
 function servesPage(repoPath) {
-  if (WEB_FILES.some((f) => existsSync13(join11(repoPath, f))))
+  if (WEB_FILES.some((f) => existsSync14(join11(repoPath, f))))
     return true;
   if (/^web:/m.test(head(join11(repoPath, "Procfile"))))
     return true;
@@ -17895,7 +18631,7 @@ function servesPage(repoPath) {
 function frontEndBeside(repoPath) {
   let dirs;
   try {
-    dirs = readdirSync2(repoPath, { withFileTypes: true });
+    dirs = readdirSync3(repoPath, { withFileTypes: true });
   } catch {
     return false;
   }
@@ -17917,10 +18653,10 @@ function mentions(text, name) {
   return new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i").test(text);
 }
 function head(path) {
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return "";
   try {
-    const fd = openSync(path, "r");
+    const fd = openSync2(path, "r");
     try {
       const buf = Buffer.alloc(READ_CAP);
       return buf.toString("utf8", 0, readSync(fd, buf, 0, READ_CAP, 0));
@@ -17945,31 +18681,31 @@ function procCommand(runner, script, body) {
   return `${base}${runner === "npm" ? " --" : ""} ${flag}`;
 }
 function detectPages(repoPath, scripts, runner) {
-  if (!scripts.build || !existsSync13(join11(repoPath, "functions")))
+  if (!scripts.build || !existsSync14(join11(repoPath, "functions")))
     return null;
-  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join11(repoPath, f)).find((f) => existsSync13(f));
+  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join11(repoPath, f)).find((f) => existsSync14(f));
   if (!cfg)
     return null;
-  const out = readFileSync9(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
+  const out = readFileSync10(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 (existsSync13(join11(repoPath, "bun.lock")) || existsSync13(join11(repoPath, "bun.lockb")))
+  if (existsSync14(join11(repoPath, "bun.lock")) || existsSync14(join11(repoPath, "bun.lockb")))
     return "bun";
-  if (existsSync13(join11(repoPath, "pnpm-lock.yaml")))
+  if (existsSync14(join11(repoPath, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync13(join11(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
+  if (existsSync14(join11(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
     return "yarn";
   return "npm";
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync14, readdirSync as readdirSync3, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
+import { existsSync as existsSync15, readdirSync as readdirSync4, 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 resolve6 } from "path";
+import { dirname as dirname5, join as join12, resolve as resolve7 } from "path";
 function isInside(dir, parent) {
   const p = parent.replace(/\/+$/, "");
   return dir === p || dir.startsWith(`${p}/`);
@@ -17981,13 +18717,13 @@ function planProject(opts, home = homedir6()) {
   const first = firstProjectsFolder(opts.parent, home);
   const parent = first ?? resolveParent(opts.parent);
   const dir = join12(parent, opts.name.trim());
-  if (existsSync14(dir))
+  if (existsSync15(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) || existsSync14(typed) || !existsSync14(home))
+  if (typed !== join12(home, PROJECTS_FOLDER) || existsSync15(typed) || !existsSync15(home))
     return null;
   return join12(realpathSync2(home), PROJECTS_FOLDER);
 }
@@ -17997,12 +18733,12 @@ function planInPlace(opts) {
     throw new UserError(`${opts.name} is not a folder name`);
   }
   const typed = join12(resolveParent(opts.parent), name);
-  if (!existsSync14(typed) || !statSync3(typed).isDirectory())
+  if (!existsSync15(typed) || !statSync4(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
-  if (existsSync14(join12(dir, ".git")))
+  if (existsSync15(join12(dir, ".git")))
     throw new UserError(`${dir} is already a project; open it instead`);
-  if (!holdsNothing(readdirSync3(dir))) {
+  if (!holdsNothing(readdirSync4(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 };
@@ -18011,9 +18747,9 @@ function resolveParent(raw) {
   const typed = expandTilde(raw.trim());
   if (!typed.startsWith("/"))
     throw new UserError(`${raw} is not a folder path`);
-  if (!existsSync14(typed))
+  if (!existsSync15(typed))
     throw new UserError(`${raw} does not exist; make it first`);
-  if (!statSync3(typed).isDirectory())
+  if (!statSync4(typed).isDirectory())
     throw new UserError(`${raw} is not a folder`);
   return realpathSync2(typed);
 }
@@ -18051,7 +18787,7 @@ async function initWithEmptyCommit(dir) {
   const exclude = await git(dir, "rev-parse", "--git-path", "info/exclude");
   if (!exclude.ok)
     throw new UserError(`git rev-parse failed: ${exclude.err}`);
-  const excludePath = resolve6(dir, exclude.out);
+  const excludePath = resolve7(dir, exclude.out);
   await mkdir2(dirname5(excludePath), { recursive: true });
   await appendFile2(excludePath, `
 ${LOCAL_EXCLUDES.join(`
@@ -18127,7 +18863,7 @@ async function ok(p, what) {
 }
 
 // ../daemon/src/repos/watcher.ts
-import { existsSync as existsSync15, watch } from "fs";
+import { existsSync as existsSync16, watch } from "fs";
 import { basename as basename2, join as join13 } from "path";
 function watchDefaultBranch(repoPath, branch, onMove) {
   let last = null;
@@ -18239,7 +18975,7 @@ function watchConfigFile(repoPath, onChange) {
   const armInner = () => {
     inner?.close();
     inner = null;
-    if (!existsSync15(dir))
+    if (!existsSync16(dir))
       return;
     try {
       inner = watch(dir, (_event, filename) => {
@@ -18293,7 +19029,7 @@ class RepoRegistry {
   }
   async boot() {
     const { state } = this.d;
-    const gone = state.worktrees.filter((wt) => !existsSync16(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
+    const gone = state.worktrees.filter((wt) => !existsSync17(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) {
@@ -18313,25 +19049,15 @@ class RepoRegistry {
       log.info("daemon", `${cold} worktrees across ${state.repos.length} repos start when opened`);
   }
   warm(repoId) {
-    if (this.warmed.has(repoId))
+    if (this.warmed.has(repoId) || !this.d.state.repo(repoId))
       return;
     this.warmed.add(repoId);
-    const repo = this.d.state.requireRepo(repoId);
-    const mine = this.d.state.worktrees.filter((w) => w.repoId === repoId && w.kind !== "spare");
-    fireAndForget(repoId, (async () => {
-      for (const wt of mine)
-        await this.d.runtime.start(wt, repo);
-    })(), "warm");
     this.d.worktrees.spare.warm(repoId);
   }
   touch(worktreeId) {
-    const { wt, repo } = this.d.state.requireWorktreeWithRepo(worktreeId);
-    if (!this.warmed.has(repo.id)) {
-      this.warm(repo.id);
+    if (!this.d.state.worktree(worktreeId))
       return;
-    }
-    if (!this.d.runtime.get(wt.id)?.procs)
-      fireAndForget(wt.id, this.d.runtime.start(wt, repo), "start on open");
+    fireAndForget(worktreeId, this.d.runtime.wake(worktreeId), "start on open");
   }
   async create(opts) {
     const inPlace = opts.mode === "init";
@@ -18370,7 +19096,7 @@ class RepoRegistry {
       return `${repo.name} is set up now`;
     if (main.promptedAt || main.lastTurn)
       return `${repo.name} has a chat now`;
-    if (existsSync16(join14(repo.path, ".claude")))
+    if (existsSync17(join14(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`;
@@ -18447,7 +19173,7 @@ class RepoRegistry {
   }
   async register(rawPath, made) {
     const path = expandTilde(rawPath);
-    if (!existsSync16(path))
+    if (!existsSync17(path))
       throw new UserError(`${path} does not exist`);
     if (!await isGitRepo(path))
       throw new UserError(`${path} is not a git repository`);
@@ -18497,28 +19223,39 @@ class RepoRegistry {
     const mine = this.d.state.worktrees.filter((w) => w.repoId === repoId);
     const tasks = mine.filter((w) => w.kind !== "main" && w.kind !== "spare");
     if (tasks.length > 0) {
-      throw new UserError(`${repo.name} still has ${tasks.length} worktree${tasks.length === 1 ? "" : "s"}; remove them first`);
+      throw new UserError(`${repo.name} still has ${tasks.length} worktree${tasks.length === 1 ? "" : "s"}; archive them first`);
     }
     this.stopWatcher(repoId);
     for (const wt of mine.filter((w) => w.kind === "spare"))
-      await this.d.worktrees.remove(wt.id, { spare: true });
+      await this.d.worktrees.discardWorktree(wt.id);
     for (const wt of mine.filter((w) => w.kind === "main")) {
       await this.d.runtime.stop(wt.id);
       this.d.state.removeWorktree(wt.id);
       this.d.worktrees.deleteChat(wt.id);
       releasePort(wt.proxyPort);
     }
+    this.d.drafts?.drop(draftKey(repoId));
     this.d.state.removeRepo(repoId);
     this.d.hub.emit("reposChanged");
     this.d.hub.emit("worktreesChanged");
   }
-  async confirmConfig(repoId, config) {
+  async confirmConfig(repoId, config, kind) {
     const repo = this.d.state.requireRepo(repoId);
     const current = readConfigFile(repo.path);
     if (current && !current.ok && current.conflict)
       throw new UserError(current.reason);
-    this.placeConfig(repo);
-    const rel = repo.configFile;
+    const was = configTarget(repo.path, !!repo.made);
+    const rel = configSibling(was, kind);
+    const moved = rel !== was && existsSync17(join14(repo.path, was));
+    if (moved && !(kind === "local" && await isTracked(repo.path, was))) {
+      try {
+        rmSync2(join14(repo.path, was));
+      } catch (e) {
+        log.warn(repoId, `could not remove ${was}`, e);
+      }
+      if (isLocalConfigFile(was))
+        await unexcludeFromGit(repo.path, was);
+    }
     if (isLocalConfigFile(rel))
       await excludeFromGit(repo.path, rel);
     const file = join14(repo.path, rel);
@@ -18529,6 +19266,7 @@ class RepoRegistry {
     } catch (e) {
       log.warn(repoId, `could not write ${rel}`, e);
     }
+    this.placeConfig(repo);
     const back = readConfigFile(repo.path);
     repo.config = back?.ok ? back.config : config;
     repo.needsSetup = false;
@@ -18598,7 +19336,7 @@ class RepoRegistry {
   }
   placeConfig(repo) {
     const rel = configTarget(repo.path, !!repo.made);
-    if (isLocalConfigFile(rel) && existsSync16(join14(repo.path, rel))) {
+    if (isLocalConfigFile(rel) && existsSync17(join14(repo.path, rel))) {
       fireAndForget(repo.id, excludeFromGit(repo.path, rel), "exclude local settings");
     }
     if (repo.configFile === rel)
@@ -18637,6 +19375,10 @@ class RepoRegistry {
     if (main)
       this.d.hub.emit("log", main.id, "config", line);
   }
+  async checkSelf(repo) {
+    if (await this.d.self.check(repo))
+      this.d.hub.emit("selfChanged");
+  }
   startWatcher(repo) {
     if (this.watchers.has(repo.id))
       return;
@@ -18644,6 +19386,7 @@ class RepoRegistry {
       this.d.worktrees.invalidateCounts();
       this.d.hub.emit("repoTick", repo.id);
       fireAndForget(repo.id, this.d.worktrees.spare.refresh(repo.id), "spare refresh");
+      fireAndForget(repo.id, this.checkSelf(repo).then(() => this.d.afterLand.run(repo.id)), "self check");
     });
     const stopCfg = watchConfigFile(repo.path, () => this.reloadConfig(repo.id));
     const stopWt = watchWorktreeDir(repo.path, () => {
@@ -18930,7 +19673,7 @@ function retitle(pages, key, title) {
 function rank(pages, now, n = KEEP) {
   return Object.keys(pages).sort(byStanding(pages, now)).slice(0, n);
 }
-function entries(pages, now) {
+function entries2(pages, now) {
   return rank(pages, now).map((path) => {
     const v = pages[path];
     return { path, score: rounded(decayed(v, now)), last: v.last, ...v.title ? { title: v.title } : {} };
@@ -19625,7 +20368,7 @@ function unseenOf(candidates, seen, hashes) {
 }
 
 // ../daemon/src/routes/service.ts
-var SAVE_DELAY_MS = 5000;
+var SAVE_DELAY_MS2 = 5000;
 var MAX_MANIFESTS = 50;
 var SCAN_CACHE = 20;
 var MAX_HASHED = 64;
@@ -19700,7 +20443,7 @@ class RouteService {
   }
   history(repoId) {
     const pages = this.d.state.visitsOf(repoId);
-    return pages ? entries(pages, this.now()) : [];
+    return pages ? entries2(pages, this.now()) : [];
   }
   historyAll() {
     const out = {};
@@ -19925,7 +20668,7 @@ class RouteService {
       } catch (e) {
         log.error("routes", "could not write the page lists", e);
       }
-    }, this.d.saveDelayMs ?? SAVE_DELAY_MS);
+    }, this.d.saveDelayMs ?? SAVE_DELAY_MS2);
     this.saveTimer.unref();
   }
   repoOf(worktreeId) {
@@ -19937,7 +20680,7 @@ class RouteService {
 }
 
 // ../daemon/src/runtime/bridge-script.ts
-import { existsSync as existsSync17, readFileSync as readFileSync10, statSync as statSync4 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11, statSync as statSync5 } from "fs";
 var LEARNED_MAX = 8;
 
 class BridgeScript {
@@ -19967,16 +20710,16 @@ class BridgeScript {
     this.cache = null;
   }
   get() {
-    if (!existsSync17(this.path))
+    if (!existsSync18(this.path))
       return "// toyon bridge not built";
-    const s = statSync4(this.path);
+    const s = statSync5(this.path);
     const stamp = `${s.mtimeMs}:${s.size}`;
     if (this.cache && stamp === this.stamp)
       return this.cache;
     this.stamp = stamp;
     const origins = [...this.origins, ...this.learned];
     this.cache = `window.__toyonShellOrigins=${JSON.stringify(origins)};
-${readFileSync10(this.path, "utf8")}`;
+${readFileSync11(this.path, "utf8")}`;
     return this.cache;
   }
 }
@@ -19993,62 +20736,394 @@ function servedLocally(origin) {
   return h === "127.0.0.1" || h === "localhost" || h === "::1" || h === "[::1]" || h.endsWith(".localhost");
 }
 
-// ../daemon/src/server/ws.ts
-import { homedir as homedir9 } from "os";
-
-// ../daemon/src/agent/config.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join16 } from "path";
-function agentConfigFiles(spec, repoPath, home = homedir8()) {
-  const file = (id, label, path) => ({
-    id,
-    label,
-    path,
-    exists: existsSync18(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"))] : []
-    ];
-  }
-  if (spec.id === "codex")
-    return [file("user-config", "config", join16(home, ".codex", "config.toml"))];
-  return [];
+// ../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 describeAgentConfig(spec, repoPath, home = homedir8()) {
-  const files = agentConfigFiles(spec, repoPath, home);
-  const servers = [];
-  if (spec.id === "claude") {
-    const user = readJson(join16(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"));
-    }
-  } else if (spec.id === "codex") {
-    servers.push(...codexServers(join16(home, ".codex", "config.toml")));
-  }
-  return { agent: spec.id, files, servers };
+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`
+  };
 }
-function readJson(path) {
-  if (!existsSync18(path))
-    return null;
+async function linux() {
+  let text;
   try {
-    const v = JSON.parse(readFileSync11(path, "utf8"));
-    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
-  } catch (e) {
-    log.warn("agent-config", `${path} is not valid JSON`, e);
+    text = await Bun.file("/proc/meminfo").text();
+  } catch {
     return null;
   }
-}
-function serversOf(raw, scope) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+  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;
+function sleepMsFrom(raw, inCloud) {
+  if (raw === "off")
+    return null;
+  const n = Number(raw);
+  if (raw && Number.isFinite(n) && n > 0)
+    return n;
+  return inCloud ? CLOUD_SLEEP_MS : LOCAL_SLEEP_MS;
+}
+var DEFAULT_SLEEP_MS = sleepMsFrom(process.env.TOYON_PROC_SLEEP_MS, cloud.enabled);
+var PRESSURE_EVERY_MS = 15000;
+var COSTS_EVERY_MS = 60000;
+var STAGGER_MS = 3000;
+
+class IdlePolicy {
+  d;
+  entries = new Map;
+  viewing = new Map;
+  queue = [];
+  draining = false;
+  sleepMs;
+  now;
+  constructor(d) {
+    this.d = d;
+    this.sleepMs = d.sleepMs === undefined ? DEFAULT_SLEEP_MS : d.sleepMs;
+    this.now = d.now ?? Date.now;
+    d.hub.on("previewRequest", (id) => this.touch(id));
+    d.hub.on("agentStatus", (id) => this.stamp(id));
+    d.hub.on("holdsChanged", (id) => this.stamp(id));
+    d.hub.on("turnSettled", (id) => {
+      if (this.recentlyViewed(id))
+        d.wake(id);
+    });
+    d.hub.on("proc", (id, p) => {
+      if (p.status !== "starting")
+        this.reconsider(id);
+    });
+    d.hub.on("worktreesChanged", () => this.reconsiderAll());
+    const every = d.setInterval ?? ((fn, ms) => {
+      setInterval(fn, ms).unref?.();
+    });
+    every(() => fireAndForget("idle", this.checkPressure(), "memory check"), PRESSURE_EVERY_MS);
+    every(() => fireAndForget("idle", this.sampleCosts(), "cost sample"), COSTS_EVERY_MS);
+  }
+  view(key, id) {
+    const prev = this.viewing.get(key) ?? null;
+    if (prev === id)
+      return;
+    if (prev !== null) {
+      this.viewing.delete(key);
+      this.entry(prev).viewers.delete(key);
+      this.record(prev);
+      this.stamp(prev);
+    }
+    if (id === null)
+      return;
+    this.viewing.set(key, id);
+    this.entry(id).viewers.add(key);
+    const wt = this.record(id);
+    this.stamp(id);
+    this.d.wake(id);
+    if (wt && wt.kind !== "spare") {
+      this.enqueue(`spare:${wt.repoId}`, async () => {
+        await this.d.runtime.awaitPreview(id, STAGGER_MS);
+        this.d.warmSpare(wt.repoId);
+        const spare = this.spareOf(wt.repoId);
+        if (spare)
+          this.d.wake(spare.id);
+      });
+    }
+  }
+  drop(key) {
+    this.view(key, null);
+  }
+  shutdown() {
+    this.recordViewed();
+  }
+  record(id) {
+    const wt = this.d.state.worktree(id);
+    if (!wt)
+      return;
+    wt.viewedAt = this.now();
+    this.d.state.save();
+    return wt;
+  }
+  recordViewed() {
+    let changed = false;
+    for (const id of new Set(this.viewing.values())) {
+      const wt = this.d.state.worktree(id);
+      if (!wt)
+        continue;
+      wt.viewedAt = this.now();
+      changed = true;
+    }
+    if (changed)
+      this.d.state.save();
+  }
+  touch(id) {
+    this.stamp(id);
+  }
+  boot() {
+    const recent = this.d.state.worktrees.filter((w) => w.kind !== "spare" && this.recentlyViewed(w.id)).sort((a, b) => (b.viewedAt ?? 0) - (a.viewedAt ?? 0));
+    for (const wt of recent) {
+      this.enqueue(`boot:${wt.id}`, async () => {
+        this.d.wake(wt.id);
+        await this.d.runtime.awaitPreview(wt.id, STAGGER_MS);
+      });
+    }
+  }
+  recentlyViewed(id) {
+    const wt = this.d.state.worktree(id);
+    return !!wt && this.now() - (wt.viewedAt ?? 0) < (this.sleepMs ?? LOCAL_SLEEP_MS);
+  }
+  isViewed(id) {
+    if ((this.entries.get(id)?.viewers.size ?? 0) > 0)
+      return true;
+    const wt = this.d.state.worktree(id);
+    if (wt?.kind !== "spare")
+      return false;
+    return this.d.state.worktrees.some((w) => w.repoId === wt.repoId && (this.entries.get(w.id)?.viewers.size ?? 0) > 0);
+  }
+  costs() {
+    const out = {};
+    for (const [id, e] of this.entries)
+      if (e.costKb !== undefined)
+        out[id] = e.costKb;
+    return out;
+  }
+  async checkPressure() {
+    const signal = await (this.d.memory ?? memoryTight)();
+    if (!signal?.tight)
+      return;
+    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`);
+  }
+  async sampleCosts() {
+    this.recordViewed();
+    const awake = this.d.runtime.awake();
+    const pgids = awake.flatMap((a) => a.pgids);
+    if (pgids.length === 0)
+      return;
+    const rss = await (this.d.costs ?? sampleCosts)(pgids);
+    for (const a of awake)
+      this.entry(a.id).costKb = a.pgids.reduce((sum, g) => sum + (rss.get(g) ?? 0), 0);
+  }
+  entry(id) {
+    let e = this.entries.get(id);
+    if (!e) {
+      e = { viewers: new Set, activeAt: this.now(), timer: null };
+      this.entries.set(id, e);
+    }
+    return e;
+  }
+  spareOf(repoId) {
+    return this.d.state.worktrees.find((w) => w.repoId === repoId && w.kind === "spare");
+  }
+  stamp(id) {
+    this.entry(id).activeAt = this.now();
+    this.reconsider(id);
+    const wt = this.d.state.worktree(id);
+    if (!wt || wt.kind === "spare")
+      return;
+    const spare = this.spareOf(wt.repoId);
+    if (!spare)
+      return;
+    this.entry(spare.id).activeAt = this.now();
+    this.reconsider(spare.id);
+  }
+  candidate(id) {
+    const wt = this.d.state.worktree(id);
+    if (!wt || this.isViewed(id) || this.busy(id))
+      return false;
+    const procs = this.d.runtime.get(id)?.procs;
+    if (!procs || procs.asleep)
+      return false;
+    const states = procs.states();
+    if (states.length === 0 || states.some((s) => s.status === "starting"))
+      return false;
+    if (wt.kind === "spare") {
+      return !this.d.state.worktrees.some((w) => w.repoId === wt.repoId && w.id !== id && this.busy(w.id));
+    }
+    return true;
+  }
+  busy(id) {
+    return this.d.runtime.busy(id);
+  }
+  reconsider(id) {
+    if (!this.candidate(id)) {
+      this.disarm(id);
+      return;
+    }
+    if (this.sleepMs === null)
+      return;
+    this.arm(id, Math.max(0, this.entry(id).activeAt + this.sleepMs - this.now()));
+  }
+  reconsiderAll() {
+    for (const id of this.entries.keys()) {
+      if (this.d.state.worktree(id))
+        continue;
+      this.disarm(id);
+      this.entries.delete(id);
+    }
+    for (const wt of this.d.state.worktrees)
+      this.reconsider(wt.id);
+  }
+  arm(id, ms) {
+    this.disarm(id);
+    const set = this.d.setTimer ?? ((fn, delay) => {
+      const t = setTimeout(fn, delay);
+      t.unref?.();
+      return t;
+    });
+    this.entry(id).timer = set(() => this.fire(id), ms);
+  }
+  disarm(id) {
+    const e = this.entries.get(id);
+    if (!e?.timer)
+      return;
+    (this.d.clearTimer ?? ((t) => clearTimeout(t)))(e.timer);
+    e.timer = null;
+  }
+  fire(id) {
+    const e = this.entry(id);
+    e.timer = null;
+    if (this.sleepMs === null || !this.candidate(id))
+      return;
+    const idle = this.now() - e.activeAt;
+    if (idle < this.sleepMs) {
+      this.arm(id, this.sleepMs - idle);
+      return;
+    }
+    this.sleep(id, `idle ${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");
+  }
+  enqueue(key, run) {
+    if (this.queue.some((q) => q.key === key))
+      return;
+    this.queue.push({ key, run });
+    if (!this.draining)
+      fireAndForget("idle", this.drain(), "wake queue");
+  }
+  async drain() {
+    this.draining = true;
+    try {
+      for (let next = this.queue.shift();next; next = this.queue.shift())
+        await next.run();
+    } finally {
+      this.draining = false;
+    }
+  }
+}
+function humanMs(ms) {
+  if (ms >= 60 * 60000 && ms % (60 * 60000) === 0)
+    return `${ms / (60 * 60000)}h`;
+  if (ms >= 60000)
+    return `${Math.round(ms / 60000)} min`;
+  return `${Math.round(ms / 1000)}s`;
+}
+
+// ../daemon/src/server/ws.ts
+import { homedir as homedir9 } from "os";
+
+// ../daemon/src/agent/config.ts
+import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join16 } from "path";
+function agentConfigFiles(spec, repoPath, home = homedir8()) {
+  const file = (id, label, path) => ({
+    id,
+    label,
+    path,
+    exists: existsSync19(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"))] : []
+    ];
+  }
+  if (spec.id === "codex")
+    return [file("user-config", "config", join16(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"));
+    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"));
+    }
+  } else if (spec.id === "codex") {
+    servers.push(...codexServers(join16(home, ".codex", "config.toml")));
+  }
+  return { agent: spec.id, files, servers };
+}
+function readJson(path) {
+  if (!existsSync19(path))
+    return null;
+  try {
+    const v = JSON.parse(readFileSync12(path, "utf8"));
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+  } catch (e) {
+    log.warn("agent-config", `${path} is not valid JSON`, e);
+    return null;
+  }
+}
+function serversOf(raw, scope) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
     return [];
   return Object.entries(raw).map(([name, v]) => {
     const rec = v && typeof v === "object" ? v : {};
@@ -20058,11 +21133,11 @@ function serversOf(raw, scope) {
   });
 }
 function codexServers(path) {
-  if (!existsSync18(path))
+  if (!existsSync19(path))
     return [];
   const out = [];
   let current = null;
-  for (const raw of readFileSync11(path, "utf8").split(`
+  for (const raw of readFileSync12(path, "utf8").split(`
 `)) {
     const line = raw.trim();
     const header = /^\[mcp_servers\.("?)([^\]"]+)\1\]$/.exec(line);
@@ -20597,7 +21672,7 @@ function daylightNow(tz, at = new Date) {
 }
 
 // ../daemon/src/server/handlers.ts
-var toast = (worktreeId, ok, message, extra = {}) => ({ t: "shipped", worktreeId, ok, message, ...extra });
+var shipped = (worktreeId, ok, message, extra = {}) => ({ t: "shipped", worktreeId, ok, message, ...extra });
 var errorText = (e) => e instanceof Error ? e.message : String(e);
 var gitStatus = async (s, ctx, worktreeId) => {
   const info = await s.worktrees.gitStatus(worktreeId);
@@ -20611,6 +21686,8 @@ var gitAndPages = async (s, ctx, worktreeId) => {
 };
 var notify = async (s, ctx, worktreeId, msg) => {
   ctx.reply(msg);
+  if (!msg.ok)
+    s.turns.markUnread(worktreeId);
   await gitStatus(s, ctx, worktreeId);
 };
 var requireRun = (s, id) => {
@@ -20622,8 +21699,18 @@ var requireRun = (s, id) => {
 var handlers = {
   async subscribe(msg, ctx, s) {
     const r = s.worktrees.readable(msg.worktreeId);
-    if (!r)
-      throw new UserError("unknown worktree");
+    if (!r) {
+      const kept = s.worktrees.archivedTranscript(msg.worktreeId);
+      if (!kept)
+        throw new UserError("unknown worktree");
+      if (!ctx.subscribe(msg.worktreeId))
+        return;
+      ctx.reply({ t: "backfill", worktreeId: msg.worktreeId, events: coalesce(kept), log: [] });
+      ctx.reply({ t: "queue", worktreeId: msg.worktreeId, items: [] });
+      ctx.reply({ t: "agent-commands", worktreeId: msg.worktreeId, commands: [] });
+      await gitStatus(s, ctx, msg.worktreeId);
+      return;
+    }
     if (!ctx.subscribe(msg.worktreeId))
       return;
     if (!r.wt) {
@@ -20633,13 +21720,11 @@ var handlers = {
       await gitAndPages(s, ctx, msg.worktreeId);
       return;
     }
-    s.repos.touch(msg.worktreeId);
     const agent = s.runtime.ensureAgent(r.wt).agent;
-    const events = agent.transcript();
     ctx.reply({
       t: "backfill",
       worktreeId: msg.worktreeId,
-      events: events.slice(-1000),
+      events: coalesce(agent.transcript()),
       log: s.runtime.recentLogs(msg.worktreeId)
     });
     ctx.reply({ t: "queue", worktreeId: msg.worktreeId, items: agent.queueItems });
@@ -20649,12 +21734,18 @@ var handlers = {
   unsubscribe(msg, ctx) {
     ctx.unsubscribe(msg.worktreeId);
   },
+  view(msg, ctx) {
+    ctx.view(msg.worktreeId);
+  },
   seen(msg, _ctx, s) {
     s.turns.markSeen(msg.worktreeId);
   },
   "mark-unread"(msg, _ctx, s) {
     s.turns.markUnread(msg.worktreeId);
   },
+  "set-draft"(msg, _ctx, s) {
+    s.drafts.set(msg.boxId, msg.text, msg.clientId);
+  },
   "refresh-git"(msg, _ctx, s) {
     s.worktrees.recount(msg.repoId);
   },
@@ -20667,7 +21758,12 @@ var handlers = {
   "forget-visit"(msg, _ctx, s) {
     s.routes.forget(msg.repoId, msg.path);
   },
-  chat(msg, _ctx, s) {
+  async chat(msg, _ctx, s) {
+    await s.worktrees.archivingNow(msg.worktreeId);
+    if (!s.state.worktree(msg.worktreeId) && s.worktrees.hasArchived(msg.worktreeId)) {
+      await s.worktrees.restore(msg.worktreeId, msg.clientId, { text: msg.text, attachments: msg.attachments });
+      return;
+    }
     requireRun(s, msg.worktreeId);
     const agent = s.runtime.agentFor(msg.worktreeId);
     if (!agent)
@@ -20678,7 +21774,6 @@ var handlers = {
   async "create-worktree"(msg, _ctx, s) {
     await s.worktrees.create(msg.repoId, msg.prompt, {
       createdBy: msg.clientId,
-      baseWorktreeId: msg.baseWorktreeId,
       variant: msg.variant,
       context: msg.context,
       attachments: msg.attachments,
@@ -20686,7 +21781,8 @@ var handlers = {
       profile: msg.profile,
       mode: msg.mode,
       model: msg.model,
-      effort: msg.effort
+      effort: msg.effort,
+      carry: msg.carry
     });
   },
   "set-worktree-profile"(msg, _ctx, s) {
@@ -20703,7 +21799,6 @@ var handlers = {
   },
   "batch-worktrees"(msg, ctx, s) {
     const repo = s.state.requireRepo(msg.repoId);
-    ctx.reply(toast("", true, "batch: planning tasks\u2026"));
     fireAndForget(msg.repoId, (async () => {
       const agent = msg.agent ?? s.state.defaultAgent ?? DEFAULT_AGENT_ID;
       const tasks = await s.planTasks(msg.prompt, repo.path, agent) ?? [msg.prompt];
@@ -20717,22 +21812,18 @@ var handlers = {
         }
       }
       const started = tasks.length - failed;
-      ctx.reply(toast("", failed === 0, failed ? `batch: ${started} started, ${failed} failed (see daemon log)` : `batch: ${started} worktree(s) started`));
+      if (failed)
+        ctx.reply(shipped("", false, `batch: ${started} started, ${failed} failed (see daemon log)`));
     })(), "batch");
   },
-  async "remove-worktree"(msg, ctx, s) {
-    const archived = await s.worktrees.remove(msg.worktreeId);
-    if (archived) {
-      ctx.reply(toast(msg.worktreeId, true, `removed ${archived.title}: archived`, {
-        ...archived.restorable ? { restoreId: archived.id } : {}
-      }));
-    }
+  async "archive-worktree"(msg, _ctx, s) {
+    await s.worktrees.archiveWorktree(msg.worktreeId);
   },
   "list-archived"(msg, ctx, s) {
     ctx.reply({ t: "archived", repoId: msg.repoId, items: s.worktrees.archived(msg.repoId) });
   },
   async "restore-worktree"(msg, _ctx, s) {
-    await s.worktrees.restore(msg.archiveId, msg.clientId);
+    await s.worktrees.restore(msg.archiveId, msg.clientId, msg.message);
   },
   async "delete-archived"(msg, _ctx, s) {
     await s.worktrees.deleteArchived(msg.archiveId);
@@ -20746,7 +21837,9 @@ var handlers = {
   async "read-file"(msg, ctx, s) {
     const head = { t: "file-read", worktreeId: msg.worktreeId, path: msg.path, ref: msg.ref, seq: msg.seq };
     try {
-      ctx.reply({ ...head, ...await s.files.read(msg.worktreeId, msg.path, msg.ref) });
+      const kept = s.worktrees.readable(msg.worktreeId) ? null : await s.worktrees.archivedFile(msg.worktreeId, msg.path, msg.ref);
+      const read = kept ? keptRead(kept.before, kept.after) : await s.files.read(msg.worktreeId, msg.path, msg.ref);
+      ctx.reply({ ...head, ...read });
     } catch (e) {
       if (!(e instanceof UserError))
         log.error(msg.worktreeId, "read-file failed", e);
@@ -20763,36 +21856,54 @@ var handlers = {
     ctx.reply({ t: "git-commit", worktreeId: msg.worktreeId, sha: msg.sha, files });
   },
   async land(msg, ctx, s) {
-    const { result, removeIds } = await s.worktrees.land(msg.worktreeId, msg.message);
+    const { result, archiveIds } = await s.worktrees.land(msg.worktreeId, msg.message);
     const suggestion = !result.ok && result.conflict ? "Bring main into this branch and resolve the conflicts, then verify the app still works." : undefined;
     if (result.ok && (result.pr || s.state.worktree(msg.worktreeId)?.pr)) {
       fireAndForget(msg.worktreeId, s.prs.refresh(msg.worktreeId), "pr refresh");
     }
-    await notify(s, ctx, msg.worktreeId, toast(msg.worktreeId, result.ok, result.message, {
+    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message, {
       merged: result.ok,
       url: result.url,
-      removeIds: removeIds ?? [],
+      archiveIds: archiveIds ?? [],
       ...suggestion ? { suggestion } : {}
     }));
   },
   async "sync-main"(msg, ctx, s) {
     const { result, defaultBranch } = await s.worktrees.sync(msg.worktreeId);
     const prompt = !result.ok && result.conflict && s.state.worktree(msg.worktreeId);
-    await notify(s, ctx, msg.worktreeId, prompt ? toast(msg.worktreeId, false, `sync conflicts with ${defaultBranch}: prompt prefilled in chat`, {
+    await notify(s, ctx, msg.worktreeId, prompt ? shipped(msg.worktreeId, false, `sync conflicts with ${defaultBranch}: prompt prefilled in chat`, {
       suggestion: `Merge ${defaultBranch} into this branch and resolve the conflicts, then verify the app still works.`
-    }) : toast(msg.worktreeId, result.ok, result.message));
+    }) : shipped(msg.worktreeId, result.ok, result.message));
   },
   async "pull-main"(msg, ctx, s) {
     const result = await s.worktrees.pull(msg.worktreeId);
-    await notify(s, ctx, msg.worktreeId, toast(msg.worktreeId, result.ok, result.message));
+    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message));
+  },
+  "run-after-land"(msg, ctx, s) {
+    const repo = s.state.repo(msg.repoId);
+    if (!repo)
+      throw new UserError("no such project");
+    if ((repo.config.afterLand ?? []).length === 0) {
+      throw new UserError(`${repo.name} has no afterLand commands in ${repo.configFile}`);
+    }
+    s.afterLand.run(msg.repoId);
+    ctx.reply({ t: "self", self: s.self.get() });
+  },
+  "restart-daemon"(_msg, _ctx, s) {
+    const refused = s.restarter.request();
+    if (refused)
+      throw new UserError(refused);
+  },
+  "update-now"(_msg, _ctx, s) {
+    return s.update.updateNow();
   },
   async commit(msg, ctx, s) {
     const result = await s.worktrees.commit(msg.worktreeId, msg.message);
-    await notify(s, ctx, msg.worktreeId, toast(msg.worktreeId, result.ok, result.message));
+    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message));
   },
   async graft(msg, ctx, s) {
-    const { target, grafted } = await s.worktrees.graft(msg.targetId, msg.sourceIds);
-    await notify(s, ctx, target.id, toast(target.id, true, `grafted ${grafted.join(", ")} into ${target.title}; merged locally, nothing pushed`));
+    const { target } = await s.worktrees.graft(msg.targetId, msg.sourceIds);
+    await gitStatus(s, ctx, target.id);
   },
   async "rename-worktree"(msg, _ctx, s) {
     await s.worktrees.rename(msg.worktreeId, msg.title);
@@ -20804,7 +21915,7 @@ var handlers = {
       fireAndForget(msg.worktreeId, agent.warmCommands(), "warm commands");
   },
   async "list-files"(msg, ctx, s) {
-    ctx.reply({ t: "files", worktreeId: msg.worktreeId, paths: await s.files.list(msg.worktreeId) });
+    ctx.reply({ t: "files", worktreeId: msg.worktreeId, ...await s.files.list(msg.worktreeId) });
   },
   async search(msg, ctx, s) {
     const { hits, truncated } = await s.files.search(msg.worktreeId, msg.query);
@@ -20837,9 +21948,8 @@ var handlers = {
   reveal(msg, _ctx, s) {
     s.files.reveal(msg.worktreeId, msg.path);
   },
-  async "discard-file"(msg, ctx, s) {
+  async "discard-file"(msg, _ctx, s) {
     await s.files.discard(msg.worktreeId, msg.path);
-    ctx.reply(toast(msg.worktreeId, true, `discarded ${msg.path}`));
     s.hub.emit("filesChanged", msg.worktreeId);
   },
   async "write-file"(msg, ctx, s) {
@@ -20856,19 +21966,17 @@ var handlers = {
     }
   },
   async "confirm-config"(msg, _ctx, s) {
-    await s.repos.confirmConfig(msg.repoId, msg.config);
+    await s.repos.confirmConfig(msg.repoId, msg.config, msg.kind);
   },
-  async "register-repo"(msg, ctx, s) {
-    const repo = await s.repos.register(msg.path);
-    ctx.reply(toast("", true, `opened ${repo.name}`));
+  async "register-repo"(msg, _ctx, s) {
+    await s.repos.register(msg.path);
   },
-  async "create-repo"(msg, ctx, s) {
+  async "create-repo"(msg, _ctx, s) {
     if (msg.mode === "clone") {
       s.repos.startImport({ parent: msg.parent, name: msg.name, url: msg.url ?? "" });
       return;
     }
-    const repo = await s.repos.create(msg);
-    ctx.reply(toast("", true, `created ${repo.name}`));
+    await s.repos.create(msg);
   },
   async "unmake-repo"(msg, _ctx, s) {
     await s.repos.unmake(msg.repoId);
@@ -20892,10 +22000,8 @@ var handlers = {
   "cancel-folder"(_msg, _ctx, s) {
     s.folderDialog.cancel();
   },
-  async "forget-repo"(msg, ctx, s) {
-    const name = s.state.requireRepo(msg.repoId).name;
+  async "forget-repo"(msg, _ctx, s) {
     await s.repos.forget(msg.repoId);
-    ctx.reply(toast("", true, `forgot ${name}`));
   },
   "set-theme"(msg, _ctx, s) {
     s.themes.setPrefs(msg.prefs);
@@ -21005,6 +22111,10 @@ var handlers = {
     const refs = await s.refs.search(msg.repoId, msg.query);
     ctx.reply({ t: "refs", repoId: msg.repoId, query: msg.query, refs });
   },
+  async "search-chats"(msg, ctx, s) {
+    const { hits, truncated } = await s.chats.search(msg.repoId, msg.query);
+    ctx.reply({ t: "chat-hits", repoId: msg.repoId, query: msg.query, hits, truncated });
+  },
   async "open-ref"(msg, _ctx, s) {
     await s.worktrees.openRef(msg.repoId, msg.kind, msg.ref, { createdBy: msg.clientId, pr: msg.pr });
   }
@@ -21023,7 +22133,7 @@ async function dispatch(msg, ctx, s) {
 }
 
 // ../daemon/src/server/http.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join17 } from "path";
 var IMMUTABLE = "private, max-age=31536000, immutable";
 var NO_STORE = "no-store";
@@ -21061,6 +22171,7 @@ function createFetch(opts) {
           dropped: new Set,
           sent: 0,
           bytes: 0,
+          view: null,
           preview: { handler, data }
         }
       }));
@@ -21069,7 +22180,15 @@ function createFetch(opts) {
       const authed = sameSecret(url.searchParams.get("token"), opts.token);
       if (authed)
         opts.noteShellOrigin(req.headers.get("origin"));
-      const data = { authed, subs: new Set, terms: new Set, dropped: new Set, sent: 0, bytes: 0 };
+      const data = {
+        authed,
+        subs: new Set,
+        terms: new Set,
+        dropped: new Set,
+        sent: 0,
+        bytes: 0,
+        view: null
+      };
       const headers = authed && remote && remoteShell ? { "set-cookie": grantCookie(grant, remote.host) } : undefined;
       if (srv.upgrade(req, { data, headers }))
         return;
@@ -21085,6 +22204,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 (!sameSecret(url.searchParams.get("token"), opts.token))
+        return new Response("unauthorized", { status: 401 });
+      const refused = opts.restart();
+      return refused ? new Response(refused, { status: 409 }) : new Response(null, { status: 202 });
+    }
     if (url.pathname === "/register" && req.method === "POST") {
       if (!sameSecret(req.headers.get("authorization"), `Bearer ${opts.token}`)) {
         return new Response("unauthorized", { status: 401 });
@@ -21106,21 +22231,22 @@ function createFetch(opts) {
       if (!sameSecret(url.searchParams.get("token"), opts.token))
         return new Response("unauthorized", { status: 401 });
       const [worktreeId, file, extra] = url.pathname.slice("/attachments/".length).split("/");
-      const path = worktreeId && file && !extra ? opts.attachments.fileFor(worktreeId, file) : null;
-      if (!path || !existsSync19(path))
+      const places = worktreeId && file && !extra ? [opts.attachments.fileFor(worktreeId, file), opts.archivedAttachment(worktreeId, file)] : [];
+      const path = places.find((p) => !!p && existsSync20(p));
+      if (!path)
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), { headers: { "cache-control": IMMUTABLE } });
     }
     const rel = url.pathname === "/" ? "/index.html" : url.pathname;
     const file = join17(opts.shellDist, rel.replaceAll("..", ""));
     const hashed = rel.startsWith("/assets/");
-    if (existsSync19(file) && Bun.file(file).size > 0) {
+    if (existsSync20(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 (existsSync19(index))
+    if (existsSync20(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 });
   };
@@ -21214,8 +22340,11 @@ function startServer(opts) {
     lag,
     worktrees: {
       total: s.state.worktrees.filter((w) => w.kind !== "spare").length,
-      running: s.runtime.runningCount()
+      running: s.runtime.runningCount(),
+      ...s.runtime.tiers()
     },
+    costs: s.idle.costs(),
+    updates: s.update.status(),
     sockets: [...sockets].map((ws) => ({ subs: [...ws.data.subs], sent: ws.data.sent, bytes: ws.data.bytes }))
   });
   let statusesInFlight = false;
@@ -21320,29 +22449,40 @@ function startServer(opts) {
   const agentsMsg = () => ({
     t: "agents",
     agents: agentInfos(),
-    defaultAgent: s.state.defaultAgent ?? DEFAULT_AGENT_ID
+    defaultAgent: s.state.defaultAgent ?? DEFAULT_AGENT_ID,
+    agentChosen: s.state.defaultAgent !== undefined
   });
   s.hub.on("agentsChanged", () => broadcast(agentsMsg()));
+  s.hub.on("selfChanged", () => broadcast({ t: "self", self: s.self.get() }));
+  s.hub.on("updateChanged", () => broadcast({ t: "update", update: s.update.get() }));
   s.hub.on("visitsChanged", (repoId) => broadcast({ t: "visits", repoId, pages: s.routes.history(repoId) }));
   s.hub.on("archiveChanged", (repoId) => broadcast({ t: "archived", repoId, items: s.worktrees.archived(repoId) }));
-  const helloFrame = async () => ({
-    t: "hello",
-    version,
-    protocol: PROTOCOL_VERSION,
-    repos: s.state.repos,
-    rows: await s.worktrees.rows({ quick: true }),
-    spares: s.worktrees.spares(),
-    themes: s.themes.themes,
-    themePrefs: s.themes.prefs,
-    agents: agentInfos(),
-    defaultAgent: s.state.defaultAgent ?? DEFAULT_AGENT_ID,
-    home: homedir9(),
-    folderDialog: process.platform === "darwin" && !cloud.enabled,
-    remote: opts.remote && { host: opts.remote.host, previews: opts.remote.previews },
-    gitIdentity: await s.repos.gitIdentity(),
-    pending: s.repos.pending,
-    visits: s.routes.historyAll()
-  });
+  s.hub.on("draftChanged", (boxId, text, clientId) => broadcast({ t: "draft", boxId, text, ...clientId ? { clientId } : {} }));
+  const helloFrame = async () => {
+    await s.update.refresh();
+    return {
+      t: "hello",
+      version,
+      protocol: PROTOCOL_VERSION,
+      repos: s.state.repos,
+      rows: await s.worktrees.rows({ quick: true }),
+      spares: s.worktrees.spares(),
+      themes: s.themes.themes,
+      themePrefs: s.themes.prefs,
+      agents: agentInfos(),
+      defaultAgent: s.state.defaultAgent ?? DEFAULT_AGENT_ID,
+      agentChosen: s.state.defaultAgent !== undefined,
+      home: homedir9(),
+      folderDialog: process.platform === "darwin" && !cloud.enabled,
+      remote: opts.remote && { host: opts.remote.host, previews: opts.remote.previews },
+      gitIdentity: await s.repos.gitIdentity(),
+      pending: s.repos.pending,
+      visits: s.routes.historyAll(),
+      self: s.self.get(),
+      update: s.update.get(),
+      drafts: s.drafts.all()
+    };
+  };
   let branded = false;
   const serverConfig = {
     hostname: cloud.bindHost,
@@ -21352,12 +22492,14 @@ function startServer(opts) {
       version,
       repos: s.repos,
       attachments: s.attachments,
+      archivedAttachment: (id, file) => s.worktrees.archivedAttachment(id, file),
       branded: () => branded,
       metrics,
       noteShellOrigin: opts.noteShellOrigin,
       remote: opts.remote,
       preview: (id) => s.runtime.get(id)?.proxy?.handler ?? null,
-      bootstrap: helloFrame
+      bootstrap: helloFrame,
+      restart: () => s.restarter.request()
     }),
     websocket: {
       maxPayloadLength: 64 * 1024 * 1024,
@@ -21377,6 +22519,8 @@ function startServer(opts) {
       close(ws) {
         if (ws.data.preview)
           ws.data.preview.handler.close(ws.data.preview.data);
+        else
+          s.idle.drop(ws.data);
         sockets.delete(ws);
       },
       async message(ws, raw) {
@@ -21409,6 +22553,14 @@ function startServer(opts) {
           },
           unsubscribe: (id) => {
             ws.data.subs.delete(id);
+            if (ws.data.view === id) {
+              ws.data.view = null;
+              s.idle.view(ws.data, null);
+            }
+          },
+          view: (id) => {
+            ws.data.view = id;
+            s.idle.view(ws.data, id);
           },
           watchTerminal: (id, stream) => {
             ws.data.terms.add(streamKey(id, stream));
@@ -21424,7 +22576,13 @@ function startServer(opts) {
         } catch (e) {
           if (!(e instanceof UserError || e instanceof ThemeImportError))
             log.error("ws", `${parsed.msg.t} failed`, e);
-          send(ws, { t: "error", message: e instanceof Error ? e.message : String(e) });
+          const m = parsed.msg;
+          const worktreeId = "worktreeId" in m ? m.worktreeId : ("archiveId" in m) ? m.archiveId : undefined;
+          send(ws, {
+            t: "error",
+            message: e instanceof Error ? e.message : String(e),
+            ...worktreeId ? { worktreeId } : {}
+          });
         }
       }
     }
@@ -21448,9 +22606,9 @@ function startServer(opts) {
 }
 
 // ../daemon/src/themes/store.ts
-import { existsSync as existsSync20, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync21, readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir10 } from "os";
-import { basename as basename4, dirname as dirname7, join as join18, resolve as resolve7 } from "path";
+import { basename as basename4, dirname as dirname7, join as join18, resolve as resolve8 } from "path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -22354,7 +23512,7 @@ class ThemeStore {
   }
 }
 function readJsonc(file) {
-  return parse7(readFileSync12(file, "utf8"), [], { allowTrailingComma: true });
+  return parse7(readFileSync13(file, "utf8"), [], { allowTrailingComma: true });
 }
 function readVscodeTheme(file, depth = 0) {
   const json = readJsonc(file);
@@ -22362,7 +23520,7 @@ function readVscodeTheme(file, depth = 0) {
     throw new ThemeImportError(`${file}: not a JSON object`);
   const t = json;
   if (typeof t.include === "string" && depth < 5) {
-    const parent = readVscodeTheme(resolve7(dirname7(file), t.include), depth + 1);
+    const parent = readVscodeTheme(resolve8(dirname7(file), t.include), depth + 1);
     return {
       ...parent,
       ...t,
@@ -22376,10 +23534,10 @@ function readVscodeTheme(file, depth = 0) {
   return t;
 }
 function loadDir(dir) {
-  if (!existsSync20(dir))
+  if (!existsSync21(dir))
     return [];
   const out = [];
-  for (const f of readdirSync4(dir)) {
+  for (const f of readdirSync5(dir)) {
     if (!/\.jsonc?$/i.test(f))
       continue;
     const file = join18(dir, f);
@@ -22398,12 +23556,12 @@ function loadDir(dir) {
   return out;
 }
 function discover(dir) {
-  if (!existsSync20(dir))
+  if (!existsSync21(dir))
     return [];
   const out = [];
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync5(dir);
   } catch {
     return out;
   }
@@ -22411,18 +23569,18 @@ function discover(dir) {
     const extDir = join18(dir, name);
     const pkgFile = join18(extDir, "package.json");
     try {
-      if (!statSync5(extDir).isDirectory() || !existsSync20(pkgFile))
+      if (!statSync6(extDir).isDirectory() || !existsSync21(pkgFile))
         continue;
-      const pkg = JSON.parse(readFileSync12(pkgFile, "utf8"));
+      const pkg = JSON.parse(readFileSync13(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 (existsSync20(nlsFile)) {
+      if (existsSync21(nlsFile)) {
         try {
-          nls = JSON.parse(readFileSync12(nlsFile, "utf8"));
+          nls = JSON.parse(readFileSync13(nlsFile, "utf8"));
         } catch {}
       }
       for (const c of themes) {
@@ -22431,7 +23589,7 @@ function discover(dir) {
         const m = /^%(.+)%$/.exec(c.label);
         if (m)
           c.label = nls[m[1]] ?? m[1];
-        const file = resolve7(extDir, c.path);
+        const file = resolve8(extDir, c.path);
         try {
           const json = readVscodeTheme(file);
           out.push(vscodeToTheme(json, { id: `vscode:${ext}:${slug(c.label)}`, name: c.label, source: "vscode" }));
@@ -22446,6 +23604,334 @@ function discover(dir) {
   return out;
 }
 
+// ../daemon/src/update/infra.ts
+import { homedir as homedir11 } from "os";
+async function latestVersion() {
+  const config = await run("npm", ["config", "get", "registry"], homedir11());
+  const registry = config.ok && config.out !== "" ? config.out : "the npm registry";
+  const r = await run("npm", ["view", "toyon", "version", "--json"], homedir11());
+  if (!r.ok)
+    return { version: null, registry };
+  try {
+    const v = JSON.parse(r.out);
+    return { version: typeof v === "string" ? v : null, registry };
+  } catch {
+    return { version: null, registry };
+  }
+}
+var LOG_POINTER = /complete log of this run/i;
+async function runInstall(command) {
+  const [cmd, ...args] = command;
+  if (!cmd)
+    return { ok: false, line: "nothing to run" };
+  const r = await runLive(cmd, args, homedir11());
+  const lines = `${r.out}
+${r.err}`.split(`
+`).map((l) => l.trim()).filter((l) => l !== "" && !LOG_POINTER.test(l));
+  return { ok: r.ok, line: lines.at(-1) ?? String(r.exit) };
+}
+
+// ../daemon/src/update/installed.ts
+async function readVersion(path) {
+  try {
+    const json = await Bun.file(path).json();
+    return typeof json.version === "string" ? json.version : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../daemon/src/update/service.ts
+var REFRESH_EVERY_MS = 60000;
+var CHECK_EVERY_MS = 6 * 60 * 60000;
+var FIRST_CHECK_MS = 2 * 60000;
+var SETTLED_MS = 2 * 60000;
+var RETRY_AFTER_MS = 24 * 60 * 60000;
+
+class UpdateService {
+  d;
+  installed = null;
+  latest = null;
+  unreachable = null;
+  installing = false;
+  failed = null;
+  wanted = false;
+  busyAt;
+  announced;
+  now;
+  constructor(d) {
+    this.d = d;
+    this.now = d.now ?? Date.now;
+    this.busyAt = this.now();
+    this.announced = JSON.stringify(this.get());
+    const every = d.setInterval ?? ((fn, ms) => {
+      setInterval(fn, ms).unref?.();
+    });
+    const later = d.setTimeout ?? ((fn, ms) => {
+      setTimeout(fn, ms).unref?.();
+    });
+    every(() => fireAndForget("update", this.tick(), "update tick"), REFRESH_EVERY_MS);
+    every(() => fireAndForget("update", this.check(), "update check"), CHECK_EVERY_MS);
+    later(() => fireAndForget("update", this.check(), "update check"), FIRST_CHECK_MS);
+    d.hub.on("agentStatus", () => {
+      this.busyAt = this.now();
+      if (this.wanted)
+        fireAndForget("update", this.proceed(), "update");
+    });
+    d.hub.on("holdsChanged", () => {
+      this.busyAt = this.now();
+    });
+  }
+  async tick() {
+    await this.refresh();
+    await this.auto();
+  }
+  async refresh() {
+    const v = await this.d.installed();
+    if (v === null)
+      return;
+    this.installed = v === this.d.running ? null : v;
+    this.announce();
+  }
+  async check() {
+    if (this.d.method === "none" || this.d.managed)
+      return;
+    const answer = await this.d.latest();
+    if (answer.version === null) {
+      this.unreachable = answer.registry;
+      return;
+    }
+    this.unreachable = null;
+    this.latest = newer(answer.version, this.d.running) ? answer.version : null;
+    this.announce();
+    await this.auto();
+  }
+  async updateNow() {
+    if (this.d.managed)
+      throw new UserError("Updates are turned off for this machine (TOYON_UPDATES=off)");
+    const target = this.target();
+    if (target === null)
+      throw new UserError("Toyon is up to date");
+    if (this.needsInstall() && this.d.command(target) === null) {
+      throw new UserError(`Run npx toyon@${target} to use it`);
+    }
+    this.failed = null;
+    this.wanted = true;
+    await this.proceed();
+  }
+  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) {
+      return null;
+    }
+    return {
+      running: this.d.running,
+      latest: this.latest,
+      installed: this.installed,
+      method: this.d.method,
+      installing: this.installing,
+      failed: this.failed,
+      restarting
+    };
+  }
+  status() {
+    return { managed: this.d.managed, unreachable: this.unreachable, latest: this.latest };
+  }
+  async auto() {
+    if (this.wanted || this.installing || this.d.managed)
+      return;
+    const target = this.target();
+    if (target === null)
+      return;
+    if (this.needsInstall() && this.d.command(target) === null)
+      return;
+    const failed = this.d.state.updateFailed;
+    if (failed?.version === target && this.now() - failed.at < RETRY_AFTER_MS)
+      return;
+    if (this.d.busy()) {
+      this.busyAt = this.now();
+      return;
+    }
+    if (this.now() - this.busyAt < SETTLED_MS)
+      return;
+    log.info("update", `nothing is busy: updating to ${target}`);
+    this.wanted = true;
+    await this.proceed();
+  }
+  target() {
+    if (this.latest && (this.installed === null || newer(this.latest, this.installed)))
+      return this.latest;
+    return this.installed;
+  }
+  needsInstall() {
+    const target = this.target();
+    return target !== null && target !== this.installed;
+  }
+  async proceed() {
+    if (!this.wanted || this.installing)
+      return;
+    if (this.d.restarter.working().length > 0) {
+      this.announce();
+      return;
+    }
+    const target = this.target();
+    const command = target === null ? null : this.d.command(target);
+    if (target !== null && command !== null && this.needsInstall()) {
+      this.installing = true;
+      this.announce();
+      log.info("update", `installing ${target}: ${command.join(" ")}`);
+      const r = await this.d.install(command);
+      this.installing = false;
+      if (!r.ok) {
+        this.wanted = false;
+        this.failed = { version: target, line: r.line, command: command.join(" ") };
+        this.d.state.setUpdateFailed({ version: target, at: this.now() });
+        log.warn("update", `installing ${target} failed: ${r.line}`);
+        this.announce();
+        return;
+      }
+      await this.refresh();
+    }
+    this.wanted = false;
+    const refused = this.d.restarter.request();
+    if (refused) {
+      this.failed = { version: target ?? this.d.running, line: refused, command: "toyon restart" };
+      log.warn("update", `restart refused: ${refused}`);
+    }
+    this.announce();
+  }
+  announce() {
+    const key = JSON.stringify(this.get());
+    if (key === this.announced)
+      return;
+    this.announced = key;
+    this.d.hub.emit("updateChanged");
+  }
+}
+
+// ../daemon/src/worktrees/chats.ts
+var CHAT_HITS_PER_WORKTREE = 20;
+var CHAT_HITS_MAX = 200;
+var MIN_QUERY = 2;
+var SNIPPET = 160;
+var BEFORE = 50;
+var bunFs2 = {
+  async stat(path) {
+    try {
+      const s = await Bun.file(path).stat();
+      return { size: s.size, mtimeMs: s.mtimeMs };
+    } catch {
+      return null;
+    }
+  },
+  async text(path) {
+    try {
+      return await Bun.file(path).text();
+    } catch {
+      return null;
+    }
+  }
+};
+var flat = (text) => text.replace(/\s+/g, " ").trim();
+function saidRows(entries) {
+  const out = [];
+  let turnTs = 0;
+  const push = (seq, role, said, ts) => {
+    const text = flat(said);
+    if (text)
+      out.push({ seq, role, text, lower: text.toLowerCase(), ts });
+  };
+  for (const { seq, event } of coalesce(entries)) {
+    if (event.type === "user-message") {
+      turnTs = event.ts;
+      push(seq, "user", event.text, event.ts);
+    } else if (event.type === "turn-start") {
+      turnTs = event.ts;
+    } else if (event.type === "text-delta") {
+      push(seq, "assistant", event.text, turnTs);
+    }
+  }
+  return out;
+}
+function snippet(text, at, length) {
+  const start = Math.max(0, Math.min(at - BEFORE, text.length - SNIPPET));
+  const end = Math.min(text.length, start + SNIPPET);
+  const head = start > 0 ? "\u2026" : "";
+  const tail = end < text.length ? "\u2026" : "";
+  return {
+    text: `${head}${text.slice(start, end)}${tail}`,
+    match: [at - start + head.length, Math.min(length, end - at)]
+  };
+}
+function searchRows(rows, needle, chat, limit = CHAT_HITS_PER_WORKTREE) {
+  const hits = [];
+  for (let i = rows.length - 1;i >= 0; i--) {
+    const row = rows[i];
+    const at = row.lower.indexOf(needle);
+    if (at < 0)
+      continue;
+    if (hits.length === limit)
+      return { hits, more: true };
+    hits.push({ ...chat, seq: row.seq, role: row.role, ts: row.ts, ...snippet(row.text, at, needle.length) });
+  }
+  return { hits, more: false };
+}
+
+class ChatSearch {
+  d;
+  said = new Map;
+  constructor(d) {
+    this.d = d;
+  }
+  async search(repoId, query) {
+    this.d.state.requireRepo(repoId);
+    const needle = flat(query).toLowerCase();
+    if (needle.length < MIN_QUERY)
+      return { hits: [], truncated: false };
+    const chats = [
+      ...this.d.state.worktrees.filter((w) => w.repoId === repoId && w.kind === "worktree").map((w) => ({ id: w.id, archived: false, path: this.d.transcriptPath(w.id) })),
+      ...this.d.archivedChats(repoId).map((a) => ({ id: a.id, archived: true, path: a.transcript }))
+    ];
+    const read = new Set;
+    const found = await Promise.all(chats.map(async (c) => {
+      const rows = await this.rowsOf(c.id, c.archived, c.path, read);
+      return searchRows(rows, needle, { worktreeId: c.id, archived: c.archived });
+    }));
+    for (const key of this.said.keys())
+      if (!read.has(key))
+        this.said.delete(key);
+    const all = found.filter((f) => f.hits.length > 0).sort((a, b) => b.hits[0].ts - a.hits[0].ts).flatMap((f) => f.hits);
+    return { hits: all.slice(0, CHAT_HITS_MAX), truncated: all.length > CHAT_HITS_MAX || found.some((f) => f.more) };
+  }
+  async rowsOf(id, archived, path, read) {
+    const live = archived ? undefined : this.d.live(id);
+    if (live) {
+      const key = `live:${id}`;
+      read.add(key);
+      return this.remember(key, `n:${live.length}`, () => saidRows(live));
+    }
+    read.add(path);
+    const fs = this.d.fs ?? bunFs2;
+    const at = await fs.stat(path);
+    if (!at)
+      return [];
+    const sig = `${at.mtimeMs}:${at.size}`;
+    const known = this.said.get(path);
+    if (known?.sig === sig)
+      return known.rows;
+    const text = await fs.text(path);
+    return text === null ? [] : this.remember(path, sig, () => saidRows(parseTranscript(text, id)));
+  }
+  remember(key, sig, rows) {
+    const known = this.said.get(key);
+    if (known?.sig === sig)
+      return known.rows;
+    const fresh = rows();
+    this.said.set(key, { sig, rows: fresh });
+    return fresh;
+  }
+}
+
 // ../daemon/src/worktrees/landing.ts
 var TAIL_CHARS = 400;
 var DIFF_CHARS = 2000;
@@ -22918,11 +24404,11 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { existsSync as existsSync22, lstatSync, readFileSync as readFileSync14, readlinkSync, rmSync as rmSync3, symlinkSync, unlinkSync } from "fs";
+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";
 
 // ../daemon/src/git/archive.ts
-import { rmSync } from "fs";
+import { rmSync as rmSync3 } from "fs";
 var archiveRef = (worktreeId) => `refs/toyon/archive/${worktreeId}`;
 async function keepState(repoPath, wtPath, ref, indexFile) {
   const head = await git(wtPath, "rev-parse", "--verify", "HEAD");
@@ -22959,7 +24445,7 @@ async function snapshotCommit(wtPath, head, indexFile) {
     ], wtPath);
     return commit.ok ? commit.out : null;
   } finally {
-    rmSync(indexFile, { force: true });
+    rmSync3(indexFile, { force: true });
   }
 }
 async function checkOutKept(repoPath, wtPath, kept, branch) {
@@ -22975,6 +24461,24 @@ async function commitOf(repoPath, ref) {
   const r = await git(repoPath, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`);
   return r.ok ? r.out : null;
 }
+var landRef = (worktreeId, n) => `refs/toyon/lands/${worktreeId}/${n}`;
+async function landingMark(worktreePath, defaultBr) {
+  const [tip, base] = await Promise.all([
+    git(worktreePath, "rev-parse", "HEAD"),
+    git(worktreePath, "merge-base", "HEAD", defaultBr)
+  ]);
+  if (!tip.ok || !base.ok || !tip.out || tip.out === base.out)
+    return null;
+  return { base: base.out, 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)
+    return;
+  for (const ref of r.out.split(`
+`).filter(Boolean))
+    await git(repoPath, "update-ref", "-d", ref);
+}
 
 // ../daemon/src/git/land.ts
 async function commitWorktree(worktreePath, message) {
@@ -23186,42 +24690,8 @@ function compareUrl(remoteUrl, base, branch) {
   return `https://github.com/${m[1]}/compare/${encodeURIComponent(base)}...${encodeURIComponent(branch)}?expand=1`;
 }
 
-// ../daemon/src/runtime/setup.ts
-var SETUP_RING = 64 * 1024;
-var SETUP_COLS = 120;
-var SETUP_ROWS = 30;
-function runSetup(cmd, cwd, onLine, extra = {}) {
-  return new Promise((resolve) => {
-    const lines = new LineSplitter;
-    try {
-      new PtyStream({
-        cwd,
-        env: { ...envStrings2(process.env), TERM: "xterm-256color", COLORTERM: "truecolor", ...extra },
-        cols: SETUP_COLS,
-        rows: SETUP_ROWS,
-        file: "sh",
-        args: ["-c", cmd],
-        ring: SETUP_RING
-      }, (data) => {
-        for (const line of lines.feed(data))
-          onLine(line);
-      }, resolve);
-    } catch (e) {
-      onLine(`could not run: ${e instanceof Error ? e.message : String(e)}`);
-      resolve(1);
-    }
-  });
-}
-function envStrings2(base) {
-  const env = {};
-  for (const [k, v] of Object.entries(base))
-    if (typeof v === "string")
-      env[k] = v;
-  return env;
-}
-
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync13, renameSync as renameSync4, rmSync as rmSync2, writeFileSync as writeFileSync8 } from "fs";
+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";
 class WorktreeArchive {
   dir;
@@ -23229,12 +24699,12 @@ class WorktreeArchive {
   constructor(dir) {
     this.dir = dir;
     mkdirSync6(dir, { recursive: true });
-    for (const id of readdirSync5(dir)) {
+    for (const id of readdirSync6(dir)) {
       const file = this.filesOf(id).record;
-      if (!existsSync21(file))
+      if (!existsSync22(file))
         continue;
       try {
-        this.records.set(id, JSON.parse(readFileSync13(file, "utf8")));
+        this.records.set(id, JSON.parse(readFileSync14(file, "utf8")));
       } catch (e) {
         log.warn("archive", `skipped an unreadable record: ${file}`, e);
       }
@@ -23262,12 +24732,18 @@ class WorktreeArchive {
   delete(id) {
     if (!this.records.has(id))
       return;
-    rmSync2(this.filesOf(id).dir, { recursive: true, force: true });
+    rmSync4(this.filesOf(id).dir, { recursive: true, force: true });
     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));
   }
+  chatFiles(id) {
+    if (!this.records.has(id))
+      return;
+    const at = this.filesOf(id);
+    return { transcript: at.transcript, attachments: at.attachments };
+  }
   filesOf(id) {
     const dir = join19(this.dir, id);
     return {
@@ -23284,18 +24760,37 @@ function summarize(r, repoId) {
     repoId,
     title: r.worktree.title,
     branch: r.worktree.branch,
+    path: r.worktree.path,
     createdAt: r.worktree.createdAt,
     archivedAt: r.archivedAt,
     ...r.prompt ? { prompt: r.prompt } : {},
     restorable: !!r.kept,
     ...r.kept?.snapshot ? { uncommitted: true } : {},
-    ...r.worktree.landed ? { landed: true } : {}
+    ...r.worktree.landed ? { landed: true } : {},
+    ...r.cost !== undefined ? { cost: r.cost } : {},
+    ...r.auto ? { auto: r.auto } : {}
   };
 }
+function lastUsage(transcript) {
+  if (!existsSync22(transcript))
+    return null;
+  const lines = readFileSync14(transcript, "utf8").split(`
+`);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    if (!lines[i]?.includes('"usage"'))
+      continue;
+    try {
+      const e = JSON.parse(lines[i]).event;
+      if (e?.type === "usage")
+        return { used: e.used, size: e.size, ...e.cost !== undefined ? { cost: e.cost } : {} };
+    } catch {}
+  }
+  return null;
+}
 function firstPrompt(transcript) {
-  if (!existsSync21(transcript))
+  if (!existsSync22(transcript))
     return;
-  for (const line of readFileSync13(transcript, "utf8").split(`
+  for (const line of readFileSync14(transcript, "utf8").split(`
 `)) {
     if (!line.includes('"user-message"'))
       continue;
@@ -23308,12 +24803,69 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync21(from))
+  if (!existsSync22(from))
     return;
-  rmSync2(to, { recursive: true, force: true });
+  rmSync4(to, { recursive: true, force: true });
   renameSync4(from, to);
 }
 
+// ../daemon/src/worktrees/archivedGit.ts
+class ArchivedGit {
+  repoPath;
+  kept;
+  lands;
+  defaultBr;
+  constructor(repoPath, kept, lands, defaultBr) {
+    this.repoPath = repoPath;
+    this.kept = kept;
+    this.lands = lands;
+    this.defaultBr = defaultBr;
+  }
+  async tailBase() {
+    const r = await git(this.repoPath, "merge-base", this.kept.head, this.defaultBr);
+    return r.ok && r.out ? r.out : this.kept.head;
+  }
+  async status() {
+    const base = await this.tailBase();
+    const { head, snapshot } = this.kept;
+    const [files, committed] = await Promise.all([
+      snapshot ? filesBetween(this.repoPath, head, snapshot) : [],
+      base === head ? [] : filesBetween(this.repoPath, base, head)
+    ]);
+    return { files, committed, head: snapshot ?? head };
+  }
+  async log() {
+    const seen = new Set;
+    const unseen = (list) => {
+      const out = list.filter((c) => !seen.has(c.sha));
+      for (const c of out)
+        seen.add(c.sha);
+      return out;
+    };
+    const landed = [];
+    for (const land of this.lands) {
+      const commits = unseen(await logRange(this.repoPath, land.base, land.tip));
+      landed.push(commits.map((c) => ({ ...c, landedAt: land.at })));
+    }
+    const base = await this.tailBase();
+    const tail = base === this.kept.head ? [] : unseen(await logRange(this.repoPath, base, this.kept.head));
+    return [...tail, ...landed.reverse().flat()];
+  }
+  commitFiles(sha) {
+    return commitFiles(this.repoPath, sha);
+  }
+  async file(path, ref) {
+    if (ref)
+      return fileAtCommit(this.repoPath, ref, path);
+    const base = await this.tailBase();
+    const [before, after] = await Promise.all([
+      gitRaw(this.repoPath, "show", `${base}:${path}`),
+      gitRaw(this.repoPath, "show", `${this.kept.snapshot ?? this.kept.head}:${path}`)
+    ]);
+    return { before: before.ok ? before.out : "", after: after.ok ? after.out : "" };
+  }
+}
+
 // ../daemon/src/worktrees/spare.ts
 import { join as join20 } from "path";
 class SparePool {
@@ -23329,7 +24881,7 @@ class SparePool {
   adopt(repoId) {
     const persisted = this.d.state.worktrees.filter((w) => w.repoId === repoId && w.kind === "spare");
     for (const extra of persisted.slice(1))
-      fireAndForget(extra.id, this.d.remove(extra.id), "stale spare removal");
+      fireAndForget(extra.id, this.d.discard(extra.id), "stale spare removal");
     const spare = persisted[0];
     if (!spare)
       return;
@@ -23386,7 +24938,7 @@ class SparePool {
       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.remove(entry.worktreeId).catch((re) => log.warn(repoId, "spare rollback failed", re));
+        await this.d.discard(entry.worktreeId).catch((re) => log.warn(repoId, "spare rollback failed", re));
       }
     }
   }
@@ -23442,12 +24994,14 @@ class SparePool {
     wt.title = slug;
     wt.createdAt = Date.now();
     this.d.state.save();
+    fireAndForget(wt.id, this.d.runtime.wake(wt.id), "wake on claim");
     fireAndForget(repoId, this.ensure(repoId), "spare warm-up");
     return wt;
   }
 }
 
 // ../daemon/src/worktrees/turns.ts
+var TURN_HOLD = "turn";
 var RECAP_DELAY_MS = Number(process.env.TOYON_RECAP_DELAY_MS) || 2 * 60000;
 
 class TurnService {
@@ -23485,11 +25039,14 @@ class TurnService {
   onStatus(worktreeId, status) {
     const prev = this.lastStatus.get(worktreeId) ?? "idle";
     this.lastStatus.set(worktreeId, status);
-    if (status === "working")
+    if (status === "working") {
       this.disarm(worktreeId);
+      this.d.hold?.(worktreeId, TURN_HOLD);
+    }
     const edge = stopOf(prev, status);
     if (!edge)
       return;
+    this.d.release?.(worktreeId, TURN_HOLD);
     const wt = this.d.state.worktree(worktreeId);
     if (!wt || wt.kind === "spare")
       return;
@@ -23587,9 +25144,6 @@ function stopOf(prev, next) {
     return "failed";
   return null;
 }
-function isUnseen(wt) {
-  return wt.unread === true || wt.lastTurn != null && (wt.seenAt == null || wt.seenAt < wt.lastTurn.at);
-}
 
 // ../daemon/src/worktrees/service.ts
 var LOCAL_CONFIG_FILES = [".env", ".env.local", ".env.development", ".env.development.local", ".dev.vars"];
@@ -23599,12 +25153,22 @@ function withoutAttachments(event) {
   const { attachments: _attachments, ...rest } = event;
   return rest;
 }
+function withCarry(context, c) {
+  if (c.count === 0)
+    return context;
+  const files = `${c.count} uncommitted ${c.count === 1 ? "file" : "files"}`;
+  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 ? `${context}
+
+${line}` : line;
+}
 var FETCH_EVERY_MS = 5 * 60000;
 
 class WorktreeService {
   d;
   spare;
   archive;
+  archiving = new Map;
   countsCache = new Map;
   discoverCache = new Map;
   usage = new Map;
@@ -23618,8 +25182,8 @@ class WorktreeService {
       runtime: d.runtime,
       paths: d.paths,
       setupAndStart: (wt, repo) => this.setupAndStart(wt, repo),
-      remove: async (id) => {
-        await this.remove(id, { spare: true });
+      discard: async (id) => {
+        await this.discardWorktree(id);
       }
     });
     for (const wt of d.state.worktrees)
@@ -23647,46 +25211,48 @@ class WorktreeService {
     const repo = this.d.state.requireRepo(repoId);
     const agent = this.d.agents.require(opts.agent ?? this.d.state.defaultAgent ?? DEFAULT_AGENT_ID).id;
     const profile = this.checkProfile(repo, opts.profile);
-    let slug = variant ? `${slugify2(prompt, false)}-v${variant.index}` : slugify2(prompt);
+    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 = opts.baseWorktreeId ? this.d.state.worktree(opts.baseWorktreeId) : undefined;
-    const fromMain = !base || base.kind === "main";
-    const agentPrompt = variant && variant.of >= 2 ? `${prompt}
+    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(`
 
-${variantLens(variant.index)}` : prompt;
-    if (fromMain) {
-      const claimed = await this.spare.claim(repoId, branch, slug);
-      if (claimed) {
-        if (variant)
-          claimed.variant = variant;
-        if (opts.createdBy)
-          claimed.createdBy = opts.createdBy;
-        claimed.promptedAt = claimed.createdAt;
-        claimed.agent = agent;
-        if (opts.mode)
-          claimed.mode = opts.mode;
-        if (opts.model)
-          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);
-        }
-        this.d.state.save();
-        this.d.hub.emit("worktreesChanged");
-        this.d.runtime.ensureAgent(claimed).agent.send(agentPrompt, { context, attachments });
-        this.scheduleNaming(claimed, prompt, variant);
-        return claimed;
+`) : prompt;
+    const claimed = await this.spare.claim(repoId, branch, slug);
+    if (claimed) {
+      if (variant)
+        claimed.variant = variant;
+      if (opts.createdBy)
+        claimed.createdBy = opts.createdBy;
+      claimed.promptedAt = claimed.createdAt;
+      claimed.agent = agent;
+      if (opts.mode)
+        claimed.mode = opts.mode;
+      if (opts.model)
+        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);
       }
+      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 });
+      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);
-    const baseBranch = fromMain ? repo.defaultBranch : base.branch;
-    await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "-b", branch, wtPath, baseBranch));
+    await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "-b", branch, wtPath, repo.defaultBranch));
     const wt = {
       id: shortId(),
       repoId,
@@ -23705,11 +25271,56 @@ ${variantLens(variant.index)}` : prompt;
       ...opts.model ? { model: opts.model } : {},
       ...opts.effort ? { effort: opts.effort } : {}
     };
-    this.launch(wt, repo, base?.path ?? repo.path);
-    this.d.runtime.ensureAgent(wt).agent.send(agentPrompt, { context, attachments });
-    this.scheduleNaming(wt, prompt, variant);
+    const carried = await this.carryMain(repo, wt, !!opts.carry);
+    this.launch(wt, repo, repo.path);
+    this.d.runtime.ensureAgent(wt).agent.send(agentPrompt, { context: withCarry(context, carried), attachments });
+    this.scheduleNaming(wt, task, variant);
+    if (carried.unmoved)
+      throw new UserError(carried.unmoved);
     return wt;
   }
+  async carryMain(repo, wt, move) {
+    const main = repo.defaultBranch;
+    if (!move)
+      return { branch: main, moved: false, count: (await statusFiles(repo.path)).length };
+    let count = 0;
+    const unmoved = await withRepoLock(repo.path, async () => {
+      count = (await statusFiles(repo.path)).length;
+      if (count === 0)
+        return;
+      const before = await git(repo.path, "rev-parse", "-q", "--verify", "refs/stash");
+      const pushed = await git(repo.path, "stash", "push", "--include-untracked", "-m", `toyon: into ${wt.title}`);
+      if (!pushed.ok)
+        return `the changes on ${main} could not be moved: ${pushed.err.trim()}`;
+      const after = await git(repo.path, "rev-parse", "-q", "--verify", "refs/stash");
+      const sha = after.out.trim();
+      if (!after.ok || before.ok && before.out.trim() === sha)
+        return;
+      const entry = async () => {
+        const list = await git(repo.path, "stash", "list", "--format=%H");
+        const i = list.out.split(`
+`).indexOf(sha);
+        return i < 0 ? null : `stash@{${i}}`;
+      };
+      const applied = await git(wt.path, "stash", "apply", sha);
+      if (applied.ok) {
+        const ref = await entry();
+        if (ref)
+          await git(repo.path, "stash", "drop", ref);
+        return;
+      }
+      log.warn(wt.id, `moving ${main}'s changes failed`, applied.err);
+      await git(wt.path, "reset", "--hard");
+      await git(wt.path, "clean", "-fd");
+      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");
+    if (mainWt)
+      this.countsCache.delete(mainWt.id);
+    return { branch: main, moved: count > 0 && !unmoved, count, unmoved };
+  }
   launch(wt, repo, depsSource, opts = {}) {
     this.d.state.addWorktree(wt);
     this.d.hub.emit("worktreesChanged");
@@ -23724,7 +25335,7 @@ ${variantLens(variant.index)}` : prompt;
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
     let slug = title;
-    if (existsSync22(join21(this.d.paths.worktreesDir, repo.name, slug)))
+    if (existsSync23(join21(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
     const wtPath = join21(this.d.paths.worktreesDir, repo.name, slug);
     await withRepoLock(repo.path, async () => {
@@ -23859,6 +25470,8 @@ ${variantLens(variant.index)}` : prompt;
     this.d.hub.emit("worktreesChanged");
   }
   scheduleNaming(wt, prompt, variant) {
+    if (!prompt.trim())
+      return;
     if (!variant) {
       fireAndForget(wt.id, (this.d.namer ?? makeNamer(this.d.runtime))(prompt, wt).then((name) => {
         if (name)
@@ -23878,12 +25491,32 @@ ${variantLens(variant.index)}` : prompt;
       }
     }), "auto-naming");
   }
-  async remove(worktreeId, opts = {}) {
+  archiveWorktree(worktreeId, opts = {}) {
+    const running = this.archiving.get(worktreeId);
+    if (running)
+      return running;
     const wt = this.d.state.worktree(worktreeId);
-    if (!wt || !(canRemove(wt) || opts.spare && wt.kind === "spare"))
-      return null;
+    if (!wt || !canArchive(wt))
+      return Promise.resolve(null);
+    if (opts.still && !opts.still())
+      return Promise.resolve(null);
+    const done = this.takeDown(wt, true, opts.reason).finally(() => this.archiving.delete(worktreeId));
+    this.archiving.set(worktreeId, done);
+    return done;
+  }
+  archivingNow(worktreeId) {
+    return this.archiving.get(worktreeId);
+  }
+  async discardWorktree(worktreeId) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt || !(canArchive(wt) || wt.kind === "spare"))
+      return;
+    await this.takeDown(wt, false);
+    this.d.drafts?.drop(worktreeId);
+  }
+  async takeDown(wt, archive, reason) {
+    const worktreeId = wt.id;
     const repo = this.d.state.requireRepo(wt.repoId);
-    const archive = wt.kind !== "spare" && opts.archive !== false;
     await this.d.runtime.stop(worktreeId);
     const kept = await withRepoLock(repo.path, async () => {
       const k = archive ? await this.keep(repo, wt) : null;
@@ -23901,9 +25534,12 @@ ${variantLens(variant.index)}` : prompt;
     releasePort(wt.proxyPort);
     let archived = null;
     if (archive)
-      archived = this.archiveChat(wt, repo, kept, sessionId);
-    else
+      archived = this.archiveChat(wt, repo, kept, sessionId, reason);
+    else {
       this.deleteChat(worktreeId);
+      if (wt.lands?.length)
+        await dropLandRefs(repo.path, worktreeId);
+    }
     this.d.hub.emit("worktreesChanged");
     return archived;
   }
@@ -23916,16 +25552,19 @@ ${variantLens(variant.index)}` : prompt;
       log.warn(wt.id, "could not keep its uncommitted changes: only its commits are archived");
     return kept;
   }
-  archiveChat(wt, repo, kept, sessionId) {
+  archiveChat(wt, repo, kept, sessionId, reason) {
     const files = this.chatFiles(wt.id);
     const prompt = firstPrompt(files.transcript);
+    const cost = (this.usage.get(wt.id) ?? lastUsage(files.transcript))?.cost;
     const rec = {
       worktree: wt,
       repoPath: repo.path,
       archivedAt: Date.now(),
       ...sessionId ? { sessionId } : {},
       ...prompt ? { prompt } : {},
-      ...kept ? { kept } : {}
+      ...cost !== undefined ? { cost } : {},
+      ...kept ? { kept } : {},
+      ...reason ? { auto: reason } : {}
     };
     try {
       this.archive.put(rec, files);
@@ -23945,8 +25584,8 @@ ${variantLens(variant.index)}` : prompt;
   deleteChat(worktreeId) {
     const files = this.chatFiles(worktreeId);
     try {
-      rmSync3(files.transcript, { force: true });
-      rmSync3(files.attachments, { recursive: true, force: true });
+      rmSync5(files.transcript, { force: true });
+      rmSync5(files.attachments, { recursive: true, force: true });
     } catch (e) {
       log.warn(worktreeId, "could not delete transcript or attachments", e);
     }
@@ -23971,14 +25610,56 @@ ${variantLens(variant.index)}` : prompt;
     });
     this.archiveChat(wt, repo, kept, sessionId);
   }
+  hasArchived(archiveId) {
+    return !!this.archive.get(archiveId);
+  }
   archived(repoId) {
     const repo = this.d.state.repo(repoId);
     return repo ? this.archive.list(repo) : [];
   }
+  archivedChats(repoId) {
+    const repo = this.d.state.repo(repoId);
+    if (!repo)
+      return [];
+    return this.archive.list(repo).flatMap((a) => {
+      const files = this.archive.chatFiles(a.id);
+      return files ? [{ id: a.id, transcript: files.transcript }] : [];
+    });
+  }
+  archivedTranscript(archiveId) {
+    const files = this.archive.chatFiles(archiveId);
+    return files ? new Transcript(files.transcript, archiveId).entries : null;
+  }
+  archivedAttachment(archiveId, file) {
+    const files = this.archive.chatFiles(archiveId);
+    return files && isAttachmentFile(file) ? join21(files.attachments, file) : null;
+  }
+  archivedGit(archiveId) {
+    const rec = this.archive.get(archiveId);
+    const repo = rec && this.repoOf(rec);
+    if (!rec?.kept || !repo)
+      return null;
+    return new ArchivedGit(repo.path, rec.kept, rec.worktree.lands ?? [], repo.defaultBranch);
+  }
+  async archivedStatus(archiveId) {
+    const kept = this.archivedGit(archiveId);
+    if (!kept)
+      return null;
+    try {
+      return await kept.status();
+    } catch (e) {
+      log.warn(archiveId, "reading its kept changes failed", e);
+      return null;
+    }
+  }
+  async archivedFile(archiveId, path, ref) {
+    const kept = this.archivedGit(archiveId);
+    return kept ? kept.file(path, ref) : null;
+  }
   repoOf(rec) {
     return this.d.state.repo(rec.worktree.repoId) ?? this.d.state.repos.find((r) => r.path === rec.repoPath);
   }
-  async restore(archiveId, createdBy) {
+  async restore(archiveId, createdBy, message) {
     const rec = this.archive.get(archiveId);
     if (!rec)
       throw new UserError("that archived worktree is gone");
@@ -23989,7 +25670,9 @@ ${variantLens(variant.index)}` : prompt;
     const kept = rec.kept;
     if (!kept)
       throw new UserError(`${old.title} was archived without its commits, so there is nothing to restore`);
-    const path = existsSync22(old.path) ? join21(dirname8(old.path), `${basename6(old.path)}-${shortId().slice(0, 4)}`) : old.path;
+    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 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`);
@@ -24038,6 +25721,8 @@ ${variantLens(variant.index)}` : prompt;
     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 });
     this.d.hub.emit("archiveChanged", repo.id);
     return wt;
   }
@@ -24047,12 +25732,15 @@ ${variantLens(variant.index)}` : prompt;
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync22(repoPath)) {
+    if (rec.kept && existsSync23(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))
+      await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
+    this.d.drafts?.drop(archiveId);
     if (repo)
       this.d.hub.emit("archiveChanged", repo.id);
   }
@@ -24122,7 +25810,7 @@ ${variantLens(variant.index)}` : prompt;
     const group = wt.variant.group;
     const siblings = this.d.state.worktrees.filter((w) => w.variant?.group === group && w.id !== worktreeId);
     for (const sibling of siblings) {
-      await this.remove(sibling.id).catch((e) => log.warn(sibling.id, "could not remove variant sibling", e));
+      await this.archiveWorktree(sibling.id).catch((e) => log.warn(sibling.id, "could not archive variant sibling", e));
     }
     delete wt.variant;
     this.d.state.save();
@@ -24163,20 +25851,28 @@ ${variantLens(variant.index)}` : prompt;
     for (const w of sources) {
       const entries = this.d.runtime.ensureAgent(w).agent.transcript();
       agent.note({ type: "grafted", title: w.title, branch: w.branch, ts: Date.now() });
-      for (const { event } of entries.slice(cutPoint(entries)))
+      for (const { event } of coalesce(entries))
         agent.note(withoutAttachments(event));
     }
     for (const w of sources)
-      await this.remove(w.id, { archive: false });
+      await this.discardWorktree(w.id);
     this.setLanded(target.id, false);
     this.countsCache.delete(target.id);
     this.d.hub.emit("worktreesChanged");
     return { target, grafted: sources.map((w) => w.title) };
   }
-  async setupAndStart(wt, repo, depsSource = repo.path, { setupCommands = true } = {}) {
+  async setupAndStart(wt, repo, depsSource = repo.path, opts = {}) {
+    this.d.runtime.markSetup(wt.id, true);
+    try {
+      await this.setupThenStart(wt, repo, depsSource, opts);
+    } finally {
+      this.d.runtime.markSetup(wt.id, false);
+    }
+  }
+  async setupThenStart(wt, repo, depsSource, { setupCommands = true }) {
     const srcNm = join21(depsSource, "node_modules");
     const dstNm = join21(wt.path, "node_modules");
-    if (existsSync22(srcNm) && !existsSync22(dstNm)) {
+    if (existsSync23(srcNm) && !existsSync23(dstNm)) {
       const started = Date.now();
       const attempts = [
         ["clonefile", ["-Rc", srcNm, dstNm]],
@@ -24193,7 +25889,7 @@ ${variantLens(variant.index)}` : prompt;
     }
     for (const f of LOCAL_CONFIG_FILES) {
       const src = join21(depsSource, f);
-      if (!existsSync22(src) || existsSync22(join21(wt.path, f)))
+      if (!existsSync23(src) || existsSync23(join21(wt.path, f)))
         continue;
       const r = await run("cp", [src, join21(wt.path, f)], wt.path);
       if (r.ok)
@@ -24313,12 +26009,14 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       const taken = await takeMainIn(wt.path, repo.defaultBranch, own);
       if (!taken.ok)
         return taken;
+      const mark = await landingMark(wt.path, repo.defaultBranch);
       const method = policy.merge ?? DEFAULT_MERGE_METHOD;
       const squash = method === "squash" ? await squashMessage(wt.path, repo.defaultBranch, suggested) : "";
       const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash);
       if (!landed.ok)
         return landed;
       mergedHere = true;
+      await this.noteLand(repo, wt, mark);
       await this.restartFromMain(wt, repo.defaultBranch);
       if (policy.land === "push") {
         const pushed = await pushMain(repo.path, repo.defaultBranch);
@@ -24334,9 +26032,21 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     }
     if (!result.ok)
       return { result };
-    const removeIds = wt.variant ? this.d.state.worktrees.filter((w) => w.variant?.group === wt.variant?.group && w.id !== wt.id).map((w) => w.id) : [];
+    const archiveIds = wt.variant ? this.d.state.worktrees.filter((w) => w.variant?.group === wt.variant?.group && w.id !== wt.id).map((w) => w.id) : [];
     const where = policy.land === "push" ? `${repo.defaultBranch}, pushed` : repo.defaultBranch;
-    return { result: { ...result, message: `${wt.title} is on ${where}` }, removeIds };
+    return { result: { ...result, message: `${wt.title} is on ${where}` }, archiveIds };
+  }
+  async noteLand(repo, wt, mark) {
+    if (!mark)
+      return;
+    const n = wt.lands?.length ?? 0;
+    const pinned = await git(repo.path, "update-ref", landRef(wt.id, n), mark.tip);
+    if (!pinned.ok) {
+      log.warn(wt.id, `could not keep the commits it landed: ${pinned.err}`);
+      return;
+    }
+    wt.lands = [...wt.lands ?? [], { ...mark, at: Date.now() }];
+    this.d.state.save();
   }
   async restartFromMain(wt, defaultBr) {
     if (!hasOwnBranch(wt))
@@ -24349,9 +26059,11 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   async prMerged(worktreeId) {
     const { wt, repo } = this.d.state.requireWorktreeWithRepo(worktreeId);
     const result = await withRepoLock(repo.path, async () => {
+      const mark = await landingMark(wt.path, repo.defaultBranch);
       const pulled = await fastForwardMain(repo.path, repo.defaultBranch);
       if (!pulled.ok)
         return pulled;
+      await this.noteLand(repo, wt, mark);
       await this.restartFromMain(wt, repo.defaultBranch);
       return pulled;
     });
@@ -24430,21 +26142,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const known = this.usage.get(worktreeId);
     if (known !== undefined)
       return known ?? undefined;
-    let found = null;
-    const file = transcriptPathFor(this.d.paths.transcriptsDir, worktreeId);
-    if (existsSync22(file)) {
-      const lines = readFileSync14(file, "utf8").split(`
-`);
-      for (let i = lines.length - 1;i >= 0 && !found; i--) {
-        if (!lines[i]?.includes('"usage"'))
-          continue;
-        try {
-          const e = JSON.parse(lines[i]).event;
-          if (e?.type === "usage")
-            found = { used: e.used, size: e.size, ...e.cost !== undefined ? { cost: e.cost } : {} };
-        } catch {}
-      }
-    }
+    const found = lastUsage(transcriptPathFor(this.d.paths.transcriptsDir, worktreeId));
     this.usage.set(worktreeId, found);
     return found ?? undefined;
   }
@@ -24513,6 +26211,14 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       return cached ?? {};
     }
   }
+  async freshCounts(worktreeId) {
+    const wt = this.d.state.worktree(worktreeId);
+    const repo = wt && this.d.state.repo(wt.repoId);
+    if (!wt || !repo)
+      return {};
+    this.countsCache.delete(worktreeId);
+    return this.counts(wt.id, wt.path, repo.defaultBranch, true);
+  }
   readable(id) {
     const wt = this.d.state.worktree(id);
     if (wt) {
@@ -24538,7 +26244,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   async gitStatus(worktreeId) {
     const r = this.readable(worktreeId);
     if (!r)
-      return null;
+      return this.archivedStatus(worktreeId);
     try {
       const isMain = r.wt?.kind === "main";
       const [files, counts, head] = await Promise.all([
@@ -24576,11 +26282,15 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   }
   async gitLog(worktreeId) {
     const r = this.readable(worktreeId);
-    return r ? logCommits(r.path, r.defaultBranch) : [];
+    if (r)
+      return logCommits(r.path, r.defaultBranch);
+    return await this.archivedGit(worktreeId)?.log() ?? [];
   }
   async commitFiles(worktreeId, sha) {
     const r = this.readable(worktreeId);
-    return r ? commitFiles(r.path, sha) : [];
+    if (r)
+      return commitFiles(r.path, sha);
+    return await this.archivedGit(worktreeId)?.commitFiles(sha) ?? [];
   }
   markPrompted(worktreeId) {
     const wt = this.d.state.worktree(worktreeId);
@@ -24647,11 +26357,115 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   }
 }
 
+// ../daemon/src/worktrees/sweep.ts
+var ARCHIVE_AFTER_MS = 2 * 60 * 60000;
+var SWEEP_EVERY_MS = 10 * 60000;
+function archiveAfterFrom(raw) {
+  if (raw === "off")
+    return null;
+  const n = Number(raw);
+  return raw && Number.isFinite(n) && n > 0 ? n : ARCHIVE_AFTER_MS;
+}
+
+class ArchiveSweep {
+  d;
+  timer = null;
+  running = false;
+  again = false;
+  afterMs;
+  constructor(d) {
+    this.d = d;
+    this.afterMs = d.afterMs === undefined ? ARCHIVE_AFTER_MS : d.afterMs;
+    if (this.afterMs === null)
+      return;
+    const every = d.setInterval ?? ((fn, ms) => {
+      const t = setInterval(fn, ms);
+      t.unref?.();
+      return t;
+    });
+    this.timer = every(() => this.request(), Math.min(d.everyMs ?? SWEEP_EVERY_MS, this.afterMs));
+  }
+  stop() {
+    if (this.timer && !this.d.setInterval)
+      clearInterval(this.timer);
+    this.timer = null;
+  }
+  request() {
+    if (this.running) {
+      this.again = true;
+      return;
+    }
+    this.running = true;
+    fireAndForget("sweep", this.sweep().finally(() => {
+      this.running = false;
+      if (!this.again)
+        return;
+      this.again = false;
+      this.request();
+    }), "archive sweep");
+  }
+  async sweep() {
+    if (this.afterMs === null)
+      return;
+    for (const repo of this.d.state.repos) {
+      const beforeGit = this.facts(repo.id, () => ({ dirty: 0, ahead: 0 }));
+      const maybe = beforeGit.rows.filter((w) => archiveReason(w, beforeGit) !== null);
+      if (maybe.length === 0)
+        continue;
+      const fresh = new Map;
+      for (const w of beforeGit.rows) {
+        if (!maybe.some((m) => m.id === w.id || !!m.variant && m.variant.group === w.variant?.group))
+          continue;
+        fresh.set(w.id, await this.d.worktrees.freshCounts(w.id));
+      }
+      const counts = (id) => fresh.get(id) ?? {};
+      for (const w of maybe) {
+        const reason = archiveReason(w, this.facts(repo.id, counts));
+        if (!reason)
+          continue;
+        log.info(w.id, `archiving on its own: ${reason}`);
+        try {
+          await this.d.worktrees.archiveWorktree(w.id, {
+            reason,
+            still: () => this.stillGoes(repo.id, w.id, counts)
+          });
+        } catch (e) {
+          log.warn(w.id, "could not archive it", e);
+        }
+      }
+    }
+  }
+  facts(repoId, counts) {
+    return {
+      now: (this.d.now ?? Date.now)(),
+      afterMs: this.afterMs ?? ARCHIVE_AFTER_MS,
+      rows: this.d.state.worktrees.filter((w) => w.repoId === repoId && w.kind !== "spare"),
+      viewed: this.d.viewed,
+      pending: this.d.busy,
+      drafted: (id) => this.d.drafts.has(id),
+      counts
+    };
+  }
+  stillGoes(repoId, id, counts) {
+    const f = this.facts(repoId, counts);
+    const wt = f.rows.find((w) => w.id === id);
+    return !!wt && archiveReason(wt, f) !== null;
+  }
+}
+
 // ../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 { shellDist: SHELL_DIST, bridgeJs: BRIDGE_JS } = locateAssets(here);
+var {
+  shellDist: SHELL_DIST,
+  bridgeJs: BRIDGE_JS,
+  sourceRoot: SOURCE_ROOT,
+  packageJson: PACKAGE_JSON
+} = locateAssets(here);
+var pruned = pruneAssets(SHELL_DIST);
+if (pruned > 0)
+  log.debug("daemon", `pruned ${pruned} assets from builds this one has outlived`);
 var paths = makePaths();
 ensureDirs(paths);
 var token = loadOrCreateToken(paths);
@@ -24697,12 +26511,15 @@ var runtime = new RuntimeRegistry({
   remote,
   grant: previewGrant(token)
 });
-var worktrees = new WorktreeService({ state, hub, runtime, paths, agents });
+var drafts = new DraftStore({ file: paths.draftsFile, hub });
+var worktrees = new WorktreeService({ state, hub, runtime, paths, agents, drafts });
 var turns = new TurnService({
   state,
   hub,
   transcript: (id) => runtime.agentFor(id)?.transcript() ?? [],
-  summarize: makeRecapper(runtime, agents, state)
+  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));
@@ -24717,10 +26534,61 @@ new LandingService({
   judge: makeLander(runtime, agents, state)
 });
 var refs = new RefSearch({ state });
+var chats = new ChatSearch({
+  state,
+  live: (id) => runtime.agentFor(id)?.transcript(),
+  transcriptPath: (id) => transcriptPathFor(paths.transcriptsDir, id),
+  archivedChats: (repoId) => worktrees.archivedChats(repoId)
+});
 var prs = new PrService({ state, hub, worktrees, view: viewPr });
-var repos = new RepoRegistry({ state, hub, runtime, worktrees });
+var self = new SelfWatch(SOURCE_ROOT);
+await self.start();
+var afterLand = new AfterLand({ state, hub, self });
+var repos = new RepoRegistry({ state, hub, runtime, worktrees, afterLand, self, drafts });
+var idle = new IdlePolicy({
+  runtime,
+  state,
+  hub,
+  wake: (id) => repos.touch(id),
+  warmSpare: (repoId) => repos.warm(repoId)
+});
+var sweep = new ArchiveSweep({
+  state,
+  viewed: (id) => idle.isViewed(id),
+  busy: (id) => runtime.busy(id),
+  drafts,
+  worktrees,
+  afterMs: archiveAfterFrom(process.env.TOYON_ARCHIVE_AFTER_MS)
+});
 var themes = new ThemeStore({ get: () => state.theme, set: (p) => state.setTheme(p) }, paths.themesDir);
 themes.load();
+var restarter = new Restarter({
+  hub,
+  state,
+  runtime,
+  refusal: () => {
+    const can = restartable();
+    return can.ok ? null : can.reason;
+  },
+  go: () => {
+    setTimeout(() => fireAndForget("daemon", shutdown("restart", { respawn: true }), "restart"), 100);
+  }
+});
+var installedPackage = cloud.enabled || process.env.TOYON_WORKTREE !== undefined ? null : PACKAGE_JSON;
+var method = installMethod(installedPackage);
+var update = new UpdateService({
+  hub,
+  state,
+  running: package_default.version,
+  method,
+  restarter,
+  installed: async () => installedPackage ? readVersion(installedPackage) : null,
+  latest: latestVersion,
+  command: (version) => installCommand(method, version),
+  install: runInstall,
+  busy: () => runtime.anyBusy(),
+  managed: process.env.TOYON_UPDATES === "off"
+});
 var { branded, stop: stopServer } = startServer({
   port,
   token,
@@ -24738,13 +26606,20 @@ var { branded, stop: stopServer } = startServer({
     design,
     routes,
     runtime,
+    idle,
     exec,
     refs,
+    chats,
+    drafts,
     prs,
     themes,
     agents,
     accounts,
     attachments: attachments2,
+    self,
+    afterLand,
+    restarter,
+    update,
     planTasks: makePlanner(agents),
     folderDialog: folderDialog()
   }
@@ -24764,6 +26639,11 @@ writeFileSync9(paths.pidFile, `${process.pid}
 `);
 var stopLagSampler = startLagSampler();
 await repos.boot();
+drafts.prune((id) => {
+  const repoId = draftRepoOf(id);
+  return repoId ? !!state.repo(repoId) : !!state.worktree(id) || worktrees.hasArchived(id);
+});
+idle.boot();
 fireAndForget("agents", agents.installMissing().then(() => probe.missing()), "agent adapter install");
 var repoArg = process.argv[2];
 if (repoArg) {
@@ -24788,19 +26668,27 @@ if (remote?.front === "edge") {
   }
 }
 var shuttingDown = false;
-async function shutdown(signal) {
+async function shutdown(signal, opts = {}) {
   if (shuttingDown)
     return;
   shuttingDown = true;
   log.info("daemon", `${signal}: stopping dev servers`);
+  idle.shutdown();
   repos.stopWatchers();
   prs.stop();
+  sweep.stop();
   stopLagSampler();
   stopServer();
   routes.flush();
+  drafts.flush();
   const deadline = new Promise((resolve) => setTimeout(resolve, 5000));
   await Promise.race([runtime.shutdown(), deadline]);
-  rmSync4(paths.pidFile, { force: true });
+  rmSync6(paths.pidFile, { force: true });
+  if (opts.respawn) {
+    await Bun.sleep(250);
+    log.info("daemon", "starting the replacement");
+    respawn(paths.logFile);
+  }
   process.exit(0);
 }
 process.on("SIGINT", () => fireAndForget("daemon", shutdown("SIGINT"), "shutdown"));