toyon 0.1.0 → 0.2.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 writeFileSync8 } from "fs";
 import { dirname as dirname9 } from "path";
 import { fileURLToPath } from "url";
 
@@ -40,6 +40,10 @@ 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 = {
@@ -183,7 +187,7 @@ function streamKey(worktreeId, stream) {
 }
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 43;
+var PROTOCOL_VERSION = 50;
 var FILE_MAX_CHARS = 5000000;
 var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var IMAGE_MAX_EDGE = 2576;
@@ -6221,6 +6225,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,6 +6260,7 @@ 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,
@@ -6267,7 +6273,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 +6280,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"),
@@ -6294,7 +6300,8 @@ var clientMsgSchema = discriminatedUnion("t", [
   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 +6317,8 @@ 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("pull-main"), worktreeId: id }),
   object({
     t: literal("write-file"),
@@ -6337,7 +6346,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 +6407,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(),
@@ -7558,7 +7573,7 @@ function canGraft(wt) {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.1.0",
+  version: "0.2.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -11885,6 +11900,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);
 }
@@ -12480,6 +12496,7 @@ function makePaths(home = process.env.TOYON_HOME ?? join3(homedir(), ".toyon"))
     stateFile: join3(home, DAEMON_FILES.state),
     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 +12523,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 +12544,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 +13048,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 +13085,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 +13113,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 +13163,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 +13171,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;
   }
@@ -13929,7 +13945,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 }) {
@@ -14611,24 +14627,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 +15005,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 +15020,7 @@ class WorktreeProcs {
   opts;
   procs = new Map;
   stopped = false;
+  asleep = false;
   lines = [];
   constructor(worktreePath, onProc, onLog, onData = () => {}, onStreamExit = () => {}, opts = {}) {
     this.worktreePath = worktreePath;
@@ -15041,7 +15067,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 +15088,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 +15114,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 +15126,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 +15173,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 +15189,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 +15241,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 +15284,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,
@@ -15272,19 +15336,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 +15362,103 @@ 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;
+  }
+  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 +15543,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 +15589,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 +15713,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 +15723,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 +16033,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 +16120,46 @@ 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, "../../..")
   };
 }
+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,9 +16249,104 @@ class Hub {
   }
 }
 
+// ../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" };
+  }
+  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.unref();
+}
+
+// ../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 renameSync3, writeFileSync as writeFileSync5 } from "fs";
+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) {
@@ -16053,7 +16367,7 @@ function loadState(paths) {
   } catch (e) {
     const backup = `${STATE_FILE}.corrupt-${Date.now()}`;
     try {
-      writeFileSync5(backup, raw);
+      writeFileSync4(backup, raw);
     } catch (be) {
       log.warn("state", "could not write the corrupt-state backup", be);
     }
@@ -16080,8 +16394,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 +16403,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;
 }
 
@@ -16841,6 +17155,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 +17221,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 +17247,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
@@ -17080,6 +17396,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;
@@ -17149,12 +17468,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;
@@ -17521,7 +17840,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 +17933,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 existsSync16, mkdirSync as mkdirSync5, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir7 } from "os";
 import { basename as basename3, dirname as dirname6, join as join14 } from "path";
 
@@ -17643,11 +18043,11 @@ function variantLens(index) {
 }
 
 // ../daemon/src/repos/browse.ts
-import { existsSync as existsSync12, statSync as statSync2 } from "fs";
+import { existsSync as existsSync12, 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;
 }
@@ -17672,7 +18072,7 @@ 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),
@@ -17706,11 +18106,11 @@ async function browsePath(raw) {
     entries.push({ path: collapseTilde(abs), name, isRepo: existsSync12(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 existsSync13, openSync as openSync2, readdirSync as readdirSync3, readFileSync as readFileSync9, 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)));
@@ -17873,7 +18273,7 @@ function markerIn(repoPath) {
     return named;
   let entries;
   try {
-    entries = readdirSync2(repoPath);
+    entries = readdirSync3(repoPath);
   } catch {
     return;
   }
@@ -17895,7 +18295,7 @@ function servesPage(repoPath) {
 function frontEndBeside(repoPath) {
   let dirs;
   try {
-    dirs = readdirSync2(repoPath, { withFileTypes: true });
+    dirs = readdirSync3(repoPath, { withFileTypes: true });
   } catch {
     return false;
   }
@@ -17920,7 +18320,7 @@ function head(path) {
   if (!existsSync13(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));
@@ -17966,10 +18366,10 @@ function detectRunner(repoPath, packageManager) {
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync14, readdirSync as readdirSync3, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
+import { existsSync as existsSync14, 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}/`);
@@ -17997,12 +18397,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 (!existsSync14(typed) || !statSync4(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
   if (existsSync14(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 };
@@ -18013,7 +18413,7 @@ function resolveParent(raw) {
     throw new UserError(`${raw} is not a folder path`);
   if (!existsSync14(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 +18451,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(`
@@ -18313,25 +18713,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";
@@ -18512,23 +18902,34 @@ class RepoRegistry {
     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 && existsSync16(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);
     try {
       mkdirSync5(dirname6(file), { recursive: true });
-      writeFileSync6(file, `${JSON.stringify(configBody(repo.path, rel, config), null, 2)}
+      writeFileSync5(file, `${JSON.stringify(configBody(repo.path, rel, config), null, 2)}
 `);
     } 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;
@@ -18637,6 +19038,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 +19049,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, () => {
@@ -19937,7 +20343,7 @@ class RouteService {
 }
 
 // ../daemon/src/runtime/bridge-script.ts
-import { existsSync as existsSync17, readFileSync as readFileSync10, statSync as statSync4 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync10, statSync as statSync5 } from "fs";
 var LEARNED_MAX = 8;
 
 class BridgeScript {
@@ -19969,7 +20375,7 @@ class BridgeScript {
   get() {
     if (!existsSync17(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;
@@ -19993,6 +20399,343 @@ function servedLocally(origin) {
   return h === "127.0.0.1" || h === "localhost" || h === "::1" || h === "[::1]" || h.endsWith(".localhost");
 }
 
+// ../daemon/src/runtime/memory.ts
+var MAC_PRESSURE_NORMAL = 1;
+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;
+  const pressure = level === MAC_PRESSURE_NORMAL ? "normal" : level === 2 ? "warn" : level === 4 ? "critical" : `level ${level}`;
+  return {
+    tight: level !== MAC_PRESSURE_NORMAL,
+    backstop: level === MAC_PRESSURE_NORMAL && available < AVAILABLE_FLOOR * 100,
+    why: `memory pressure ${pressure} with ${available}% available`
+  };
+}
+async function linux() {
+  let text;
+  try {
+    text = await Bun.file("/proc/meminfo").text();
+  } catch {
+    return null;
+  }
+  const field = (name) => {
+    const m = text.match(new RegExp(`^${name}:\\s+(\\d+)`, "m"));
+    return m ? Number(m[1]) : null;
+  };
+  const total = field("MemTotal");
+  const available = field("MemAvailable");
+  if (!total || available === null)
+    return null;
+  const percent = Math.round(available / total * 100);
+  return { tight: available / total < AVAILABLE_FLOOR, backstop: false, 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 || !signal.tight && !signal.backstop)
+      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;
+    const why = `${signal.why}; least recently used`;
+    if (signal.tight)
+      this.sleep(pick.id, why);
+    else
+      log.info(pick.id, `would sleep on the backstop: ${why}`);
+  }
+  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) {
+    const agent = this.d.runtime.agentFor(id);
+    if (agent && (agent.status !== "idle" || agent.queueItems.length > 0))
+      return true;
+    return this.d.runtime.holdCount(id) > 0;
+  }
+  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";
 
@@ -20597,7 +21340,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 +21354,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 +21367,17 @@ 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: [] });
+      return;
+    }
     if (!ctx.subscribe(msg.worktreeId))
       return;
     if (!r.wt) {
@@ -20633,13 +21387,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,6 +21401,9 @@ 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);
   },
@@ -20678,7 +21433,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 +21440,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 +21458,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 +21471,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 "remove-worktree"(msg, _ctx, s) {
+    await s.worktrees.remove(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);
@@ -20768,7 +21518,7 @@ var handlers = {
     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 ?? [],
@@ -20778,21 +21528,41 @@ var handlers = {
   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 busy = s.state.worktrees.filter((w) => s.runtime.agentFor(w.id)?.status === "working");
+    if (busy.length > 0) {
+      const names = busy.map((w) => w.title).join(", ");
+      throw new UserError(`still working on ${names}; restart once that settles`);
+    }
+    const refused = s.restart();
+    if (refused)
+      throw new UserError(refused);
   },
   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);
@@ -20837,9 +21607,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 +21625,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 +21659,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 +21770,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 });
   }
@@ -21061,6 +21830,7 @@ function createFetch(opts) {
           dropped: new Set,
           sent: 0,
           bytes: 0,
+          view: null,
           preview: { handler, data }
         }
       }));
@@ -21069,7 +21839,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;
@@ -21106,8 +21884,9 @@ 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 && existsSync19(p));
+      if (!path)
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), { headers: { "cache-control": IMMUTABLE } });
     }
@@ -21214,8 +21993,10 @@ 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(),
     sockets: [...sockets].map((ws) => ({ subs: [...ws.data.subs], sent: ws.data.sent, bytes: ws.data.bytes }))
   });
   let statusesInFlight = false;
@@ -21320,9 +22101,11 @@ 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("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 () => ({
@@ -21336,12 +22119,14 @@ function startServer(opts) {
     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()
+    visits: s.routes.historyAll(),
+    self: s.self.get()
   });
   let branded = false;
   const serverConfig = {
@@ -21352,6 +22137,7 @@ function startServer(opts) {
       version,
       repos: s.repos,
       attachments: s.attachments,
+      archivedAttachment: (id, file) => s.worktrees.archivedAttachment(id, file),
       branded: () => branded,
       metrics,
       noteShellOrigin: opts.noteShellOrigin,
@@ -21377,6 +22163,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 +22197,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 +22220,12 @@ 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 worktreeId = "worktreeId" in parsed.msg ? parsed.msg.worktreeId : undefined;
+          send(ws, {
+            t: "error",
+            message: e instanceof Error ? e.message : String(e),
+            ...worktreeId ? { worktreeId } : {}
+          });
         }
       }
     }
@@ -21448,9 +22249,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 existsSync20, readdirSync as readdirSync5, readFileSync as readFileSync12, statSync as statSync6, writeFileSync as writeFileSync6 } 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) {
@@ -22347,7 +23148,7 @@ class ThemeStore {
       name: json?.name ?? base,
       source: "file"
     });
-    writeFileSync7(join18(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
+    writeFileSync6(join18(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
 `);
     this.load();
     return theme;
@@ -22362,7 +23163,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,
@@ -22379,7 +23180,7 @@ function loadDir(dir) {
   if (!existsSync20(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);
@@ -22403,7 +23204,7 @@ function discover(dir) {
   const out = [];
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync5(dir);
   } catch {
     return out;
   }
@@ -22411,7 +23212,7 @@ 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() || !existsSync20(pkgFile))
         continue;
       const pkg = JSON.parse(readFileSync12(pkgFile, "utf8"));
       const themes = pkg.contributes?.themes;
@@ -22431,7 +23232,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 +23247,129 @@ function discover(dir) {
   return out;
 }
 
+// ../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 +23842,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 existsSync22, 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 +23883,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) {
@@ -23186,42 +24110,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 existsSync21, mkdirSync as mkdirSync6, readdirSync as readdirSync6, readFileSync as readFileSync13, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
 import { join as join19 } from "path";
 class WorktreeArchive {
   dir;
@@ -23229,7 +24119,7 @@ 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))
         continue;
@@ -23248,7 +24138,7 @@ class WorktreeArchive {
     mkdirSync6(at.dir, { recursive: true });
     move(from.transcript, at.transcript);
     move(from.attachments, at.attachments);
-    writeFileSync8(at.record, JSON.stringify(rec, null, 2));
+    writeFileSync7(at.record, JSON.stringify(rec, null, 2));
     this.records.set(rec.worktree.id, rec);
   }
   take(id, to) {
@@ -23262,12 +24152,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,14 +24180,32 @@ 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 } : {}
   };
 }
+function lastUsage(transcript) {
+  if (!existsSync21(transcript))
+    return null;
+  const lines = readFileSync13(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))
     return;
@@ -23310,8 +24224,8 @@ function firstPrompt(transcript) {
 function move(from, to) {
   if (!existsSync21(from))
     return;
-  rmSync2(to, { recursive: true, force: true });
-  renameSync4(from, to);
+  rmSync4(to, { recursive: true, force: true });
+  renameSync3(from, to);
 }
 
 // ../daemon/src/worktrees/spare.ts
@@ -23442,12 +24356,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 +24401,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;
@@ -23599,6 +24518,15 @@ 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 {
@@ -23647,46 +24575,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 +24635,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");
@@ -23859,6 +24834,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)
@@ -23919,12 +24896,14 @@ ${variantLens(variant.index)}` : prompt;
   archiveChat(wt, repo, kept, sessionId) {
     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 } : {},
+      ...cost !== undefined ? { cost } : {},
       ...kept ? { kept } : {}
     };
     try {
@@ -23945,8 +24924,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);
     }
@@ -23975,10 +24954,27 @@ ${variantLens(variant.index)}` : prompt;
     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;
+  }
   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");
@@ -24038,6 +25034,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;
   }
@@ -24163,7 +25161,7 @@ ${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)
@@ -24173,7 +25171,15 @@ ${variantLens(variant.index)}` : prompt;
     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)) {
@@ -24430,21 +25436,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;
   }
@@ -24651,7 +25643,10 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
 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 } = 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);
@@ -24702,7 +25697,9 @@ 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,8 +25714,24 @@ 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 });
+var idle = new IdlePolicy({
+  runtime,
+  state,
+  hub,
+  wake: (id) => repos.touch(id),
+  warmSpare: (repoId) => repos.warm(repoId)
+});
 var themes = new ThemeStore({ get: () => state.theme, set: (p) => state.setTheme(p) }, paths.themesDir);
 themes.load();
 var { branded, stop: stopServer } = startServer({
@@ -24738,13 +25751,24 @@ var { branded, stop: stopServer } = startServer({
     design,
     routes,
     runtime,
+    idle,
     exec,
     refs,
+    chats,
     prs,
     themes,
     agents,
     accounts,
     attachments: attachments2,
+    self,
+    afterLand,
+    restart: () => {
+      const can = restartable();
+      if (!can.ok)
+        return can.reason;
+      fireAndForget("daemon", shutdown("restart", { respawn: true }), "restart");
+      return null;
+    },
     planTasks: makePlanner(agents),
     folderDialog: folderDialog()
   }
@@ -24760,10 +25784,11 @@ bridge.setShellOrigins([
   ],
   ...remote ? [`https://${remote.host}`] : []
 ]);
-writeFileSync9(paths.pidFile, `${process.pid}
+writeFileSync8(paths.pidFile, `${process.pid}
 `);
 var stopLagSampler = startLagSampler();
 await repos.boot();
+idle.boot();
 fireAndForget("agents", agents.installMissing().then(() => probe.missing()), "agent adapter install");
 var repoArg = process.argv[2];
 if (repoArg) {
@@ -24788,11 +25813,12 @@ 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();
   stopLagSampler();
@@ -24800,7 +25826,12 @@ async function shutdown(signal) {
   routes.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"));