toyon 0.16.0 → 0.17.0

package/dist/daemon.js

@@ -1,7 +1,8 @@
 // @bun
 // ../daemon/src/index.ts
 import { rmSync as rmSync9, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname13, join as join31 } from "path";
+import { homedir as homedir15 } from "os";
+import { dirname as dirname13, join as join32 } from "path";
 import { fileURLToPath } from "url";
 
 // ../shared/src/protocol/events.ts
@@ -342,6 +343,8 @@ var APP_SCHEME = "toyon";
 var START_LINK = `${APP_SCHEME}://start`;
 var OFFLINE_SLOTS = { start: "data-start", port: "data-port" };
 var LSREGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+var FD_LIMIT_LOW = 4096;
+var fdLimitLine = (n) => `open-file limit is ${n}; raise it with ulimit -n 8192 before toyon starts`;
 var DAEMON_FILES = {
   token: "token",
   helper: "Toyon.app",
@@ -6598,7 +6601,7 @@ ${text.slice(text.length - (CONTEXT_CHARS - HEAD_CHARS))}`;
 }
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 112;
+var PROTOCOL_VERSION = 115;
 var PAGE_ERROR_MAX_CHARS = 2000;
 var PAGE_TITLE_MAX_CHARS = 1000;
 var FILE_MAX_CHARS = 5000000;
@@ -6947,6 +6950,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("list-files"), worktreeId: id }),
   object({ t: literal("list-commands"), worktreeId: id }),
   object({ t: literal("search"), worktreeId: id, query: string2().max(500) }),
+  object({ t: literal("search-stop") }),
   object({ t: literal("find-element"), worktreeId: id, seq, element: elementTraitsSchema }),
   object({ t: literal("design-scan"), worktreeId: id }),
   object({ t: literal("discard-files"), worktreeId: id, paths: array(relPath).min(1).max(500) }),
@@ -7011,6 +7015,7 @@ var clientMsgSchema = discriminatedUnion("t", [
     start: string2().max(4000),
     purpose: _enum(["location", "open"])
   }),
+  object({ t: literal("choose-file"), start: string2().max(4000) }),
   object({ t: literal("cancel-folder") }),
   object({ t: literal("forget-repo"), repoId: id }),
   object({ t: literal("set-theme"), prefs: themePrefsSchema }),
@@ -8514,7 +8519,7 @@ async function turnRemoteOff(ts, daemonPort, file, was) {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.16.0",
+  version: "0.17.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -12617,17 +12622,26 @@ function envLevel() {
   return v && v in LEVELS ? v : "info";
 }
 var threshold = LEVELS[envLevel()];
-function fmtExtra(extra) {
+var BUGS = [TypeError, RangeError, ReferenceError, SyntaxError];
+function fmtError(level, e) {
+  const line = `${e.name}: ${e.message}`;
+  const whole = level === "error" || threshold <= LEVELS.debug || BUGS.some((c) => e instanceof c);
+  return whole ? e.stack ?? line : line;
+}
+function fmtExtra(level, extra) {
   if (extra === undefined)
     return "";
   if (extra instanceof Error)
-    return ` ${extra.stack ?? extra.message}`;
+    return ` ${fmtError(level, extra)}`;
   try {
     return ` ${JSON.stringify(extra)}`;
   } catch {
     return ` ${String(extra)}`;
   }
 }
+function formatLine(level, tag, message, extra, iso = new Date().toISOString()) {
+  return `${iso.slice(11, 19)} ${level.padEnd(5)} [${tag}] ${message}${fmtExtra(level, extra)}`;
+}
 var lastDay = "";
 function write(level, tag, message, extra) {
   if (LEVELS[level] < threshold)
@@ -12639,7 +12653,7 @@ function write(level, tag, message, extra) {
     process.stderr.write(`-------- ${day} --------
 `);
   }
-  process.stderr.write(`${iso.slice(11, 19)} ${level.padEnd(5)} [${tag}] ${message}${fmtExtra(extra)}
+  process.stderr.write(`${formatLine(level, tag, message, extra, iso)}
 `);
 }
 var log = {
@@ -13794,23 +13808,90 @@ import { join as join3 } from "path";
 // ../daemon/src/core/metrics.ts
 var WARN_MS = 50;
 var TICK_MS = 250;
+var SLEEP_MS = 30000;
 var lastGit = { cmd: "", ms: 0, at: 0 };
+var gitSpawns = {};
+function noteSpawn(args) {
+  const key = args.slice(0, 2).join(" ");
+  gitSpawns[key] = (gitSpawns[key] ?? 0) + 1;
+}
+var treeReads = { core: 0, extras: 0, superseded: 0, failed: 0 };
+var syncHot = {};
+function noteSync(name, ms) {
+  if (ms > (syncHot[name] ?? 0))
+    syncHot[name] = ms;
+}
+var limits = { fdLimit: 0 };
+var lagHist = { over50: 0, over100: 0, over250: 0, over1000: 0 };
 var lag = { last: 0, max: 0, maxCause: null, over: 0 };
+
+class LagMinute {
+  minute = -1;
+  ticks = 0;
+  worst = 0;
+  git = null;
+  gitMs = null;
+  note(now, late, git) {
+    const minute = Math.floor(now / 60000);
+    let out = null;
+    if (minute !== this.minute) {
+      if (this.ticks > 0)
+        out = { ticks: this.ticks, worst: this.worst, git: this.git, gitMs: this.gitMs };
+      this.minute = minute;
+      this.ticks = 0;
+      this.worst = 0;
+      this.git = null;
+      this.gitMs = null;
+    }
+    if (late > WARN_MS && late <= SLEEP_MS) {
+      this.ticks++;
+      if (late > this.worst) {
+        this.worst = late;
+        this.git = git?.cmd ?? null;
+        this.gitMs = git?.ms ?? null;
+      }
+    }
+    return out;
+  }
+}
+function describeLag(l) {
+  const times = l.ticks === 1 ? "once" : `${l.ticks} times`;
+  const cause = l.git ? ` after ${l.git} (${l.gitMs}ms)` : "";
+  return `event loop late ${times} in the last minute, worst ${l.worst}ms${cause}`;
+}
 function startLagSampler() {
   let expected = Date.now() + TICK_MS;
+  const minute = new LagMinute;
   const t = setInterval(() => {
     const now = Date.now();
     const late = Math.max(0, now - expected);
     expected = now + TICK_MS;
     lag.last = late;
+    const git = lastGit.cmd && now - lastGit.at < TICK_MS + late ? { cmd: lastGit.cmd, ms: lastGit.ms } : null;
+    const line = minute.note(now, late, git);
+    if (line) {
+      log.warn("lag", describeLag(line), {
+        ticks: line.ticks,
+        worst: line.worst,
+        ...line.git ? { git: line.git, gitMs: line.gitMs } : {}
+      });
+    }
+    if (late > SLEEP_MS)
+      return;
     if (late > lag.max) {
       lag.max = late;
-      lag.maxCause = now - lastGit.at < TICK_MS + late ? `${lastGit.cmd} (${lastGit.ms}ms)` : null;
+      lag.maxCause = git ? `${git.cmd} (${git.ms}ms)` : null;
     }
-    if (late > WARN_MS) {
+    if (late > WARN_MS)
       lag.over++;
-      log.warn("lag", `event loop late by ${late}ms`, lastGit.cmd ? { lastGit: lastGit.cmd, ms: lastGit.ms } : undefined);
-    }
+    if (late > 50)
+      lagHist.over50++;
+    if (late > 100)
+      lagHist.over100++;
+    if (late > 250)
+      lagHist.over250++;
+    if (late > 1000)
+      lagHist.over1000++;
   }, TICK_MS);
   return () => clearInterval(t);
 }
@@ -13860,8 +13941,13 @@ var NO_PROMPT = {
   GIT_SSH_COMMAND: "ssh -o BatchMode=yes"
 };
 var SPAWN_ENV = { GIT_OPTIONAL_LOCKS: "0" };
-async function run(cmd, args, cwd, env) {
+var RUN_CEILING_MS = 10 * 60000;
+async function run(cmd, args, cwd, env, opts = {}) {
   const started = Date.now();
+  const ceiling = opts.timeoutMs ?? RUN_CEILING_MS;
+  let timer;
+  if (cmd === GIT)
+    noteSpawn(args);
   try {
     const p = Bun.spawn([cmd, ...args], {
       cwd,
@@ -13870,17 +13956,31 @@ async function run(cmd, args, cwd, env) {
       stdin: "ignore",
       env: { ...process.env, ...SPAWN_ENV, ...env }
     });
-    const [rawOut, err, status] = await Promise.all([
-      new Response(p.stdout).text(),
-      new Response(p.stderr).text(),
-      p.exited
-    ]);
-    const exit = p.signalCode ?? status;
-    return { ok: status === 0, out: rawOut.trim(), rawOut, err: err.trim(), exit };
+    const done = (async () => {
+      const [rawOut, err, status] = await Promise.all([
+        new Response(p.stdout).text(),
+        new Response(p.stderr).text(),
+        p.exited
+      ]);
+      const exit = p.signalCode ?? status;
+      return { ok: status === 0, out: rawOut.trim(), rawOut, err: err.trim(), exit };
+    })();
+    const gaveUp = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        const what = `${cmd === GIT ? "git" : cmd} ${args.slice(0, 3).join(" ")}`;
+        const msg = `gave up after ${describeDuration(ceiling)}`;
+        log.warn("git", `${what} ${msg} in ${cwd}`);
+        p.kill("SIGKILL");
+        resolve({ ok: false, out: "", rawOut: "", err: msg, exit: "timeout" });
+      }, ceiling);
+    });
+    return await Promise.race([done, gaveUp]);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return { ok: false, out: "", rawOut: "", err: msg, exit: msg };
   } finally {
+    if (timer)
+      clearTimeout(timer);
     if (cmd === GIT) {
       lastGit.cmd = `git ${args.slice(0, 3).join(" ")}`;
       lastGit.ms = Date.now() - started;
@@ -13942,6 +14042,80 @@ async function runLive(cmd, args, cwd, opts = {}) {
     }
   }
 }
+async function runRows(cmd, args, cwd, opts) {
+  const started = Date.now();
+  const rowMax = opts.rowMax ?? 8192;
+  let stopped = false;
+  try {
+    const p = Bun.spawn([cmd, ...args], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+      env: { ...process.env, ...SPAWN_ENV }
+    });
+    const reader = p.stdout.getReader();
+    const stop = () => {
+      stopped = true;
+      p.kill();
+      reader.cancel().catch(() => {});
+    };
+    if (opts.signal?.aborted)
+      stop();
+    else
+      opts.signal?.addEventListener("abort", stop, { once: true });
+    const pump = async () => {
+      const dec = new TextDecoder;
+      let buf = "";
+      let skipping = false;
+      while (!stopped) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buf += dec.decode(value, { stream: true });
+        while (!stopped) {
+          const nl = buf.indexOf(`
+`);
+          if (nl < 0) {
+            if (skipping)
+              buf = "";
+            else if (buf.length > rowMax) {
+              const keep = buf.slice(0, rowMax);
+              buf = "";
+              skipping = true;
+              if (opts.onRow(keep) === false)
+                stop();
+            }
+            break;
+          }
+          const row = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          if (skipping) {
+            skipping = false;
+            continue;
+          }
+          if (row && opts.onRow(row.length > rowMax ? row.slice(0, rowMax) : row) === false)
+            stop();
+        }
+      }
+      if (!stopped && buf && !skipping)
+        opts.onRow(buf);
+    };
+    const [, err, status] = await Promise.all([pump(), new Response(p.stderr).text(), p.exited]);
+    opts.signal?.removeEventListener("abort", stop);
+    const exit = p.signalCode ?? status;
+    return { ok: status === 0 || stopped, out: "", err: err.trim(), exit, stopped };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, out: "", err: msg, exit: msg, stopped };
+  } finally {
+    if (cmd === GIT) {
+      lastGit.cmd = `git ${args.slice(0, 3).join(" ")}`;
+      lastGit.ms = Date.now() - started;
+      lastGit.at = Date.now();
+    }
+  }
+}
 function watchHooks(stream, onHook) {
   let failed;
   if (!stream)
@@ -14443,7 +14617,26 @@ function planEdited(cwd, rel, proposed) {
 
 // ../daemon/src/agent/sandbox.ts
 var CACHE_DIRS = [".bun", ".npm", ".cache", ".yarn", ".pnpm-store", "Library/Caches"].map((d) => resolve2(homedir2(), d));
-var AGENT_SETTINGS = [".claude", ".codex", ".opencode", "opencode.json", "opencode.jsonc"];
+var AGENT_SETTINGS = [
+  ".claude/settings.json",
+  ".claude/settings.local.json",
+  ".claude/hooks",
+  ".claude/agents",
+  ".codex/config.toml",
+  ".codex/hooks.json",
+  ".codex/hooks",
+  ".codex/rules",
+  "opencode.json",
+  "opencode.jsonc",
+  ".opencode/opencode.json",
+  ".opencode/opencode.jsonc",
+  ".opencode/plugin",
+  ".opencode/plugins",
+  ".opencode/tool",
+  ".opencode/tools",
+  ".opencode/agent",
+  ".opencode/agents"
+];
 function uniq2(xs) {
   return [...new Set(xs)];
 }
@@ -14588,10 +14781,7 @@ function installErrorLine(stderr) {
 }
 var UNTRUSTED_CA = /UNKNOWN_CERTIFICATE_VERIFICATION_ERROR|SELF_SIGNED_CERT|UNABLE_TO_GET_ISSUER_CERT|UNABLE_TO_VERIFY_LEAF_SIGNATURE/;
 var bunInstall = async (dir) => {
-  const r = await run(process.execPath, ["install", "--no-progress", "--no-summary"], dir, {
-    NO_COLOR: "1",
-    FORCE_COLOR: "0"
-  });
+  const r = await run(process.execPath, ["install", "--no-progress", "--no-summary"], dir, { NO_COLOR: "1", FORCE_COLOR: "0" }, { timeoutMs: 30 * 60000 });
   return { ok: r.ok, err: r.ok ? "" : installErrorLine(r.err) };
 };
 var RETRY_AFTER_MS = 30000;
@@ -15676,7 +15866,7 @@ function decide(req, bounds, cwd, mode = "auto", sandboxed = true) {
         kind: "reject",
         tool,
         path: raw,
-        reason: "Agent settings are managed by Toyon, not written by the agent."
+        reason: "Agent settings, hooks and plugin code are yours to change, never the agent's."
       };
     }
     if (kind && NON_WRITE_KINDS.has(kind))
@@ -15718,14 +15908,14 @@ var SYSTEM_APPEND = [
   "You are working inside a dedicated git worktree managed by Toyon.",
   "Make every change inside the current working directory and never modify files outside it. Reading files outside it is fine when the user points you there.",
   "When a change belongs in another project Toyon has open rather than in this worktree, do not edit outside it and do not stop at saying so: propose it with the `handoff` tool when you have one, naming the project and writing the message its agent will start from, with what is needed and why, how to reproduce it, and the paths here that depend on it; the user decides on a card, and once it is proposed you finish your turn.",
-  "A write Toyon refuses (outside the worktree, or to an agent's own settings such as .claude/ or opencode.json) was refused by Toyon and not by the user, who was never asked. Report it as the boundary that stopped it, never as the user declining.",
+  "A write Toyon refuses (outside the worktree, or to an agent's settings, hooks or plugin code such as .claude/settings.json, .claude/hooks or opencode.json) was refused by Toyon and not by the user, who was never asked. Report it as the boundary that stopped it, never as the user declining.",
   "Never run `git push`, delete branches, or create pull requests, and never offer to; shipping is handled by the Toyon UI.",
   "Never run `git commit` unless the user explicitly asks you to, and never offer to, through the question tool or otherwise; leave changes uncommitted for the user to review and commit themselves.",
   "Keep the scope tight: do the asked task well, then stop. A follow-up the user might want later is a sentence in your reply, not a question.",
   "When the work is done and the only thing left is whether to do something you recommend, do not end your turn on a prose offer waiting for a yes. Ask it with your question tool when you have one: one question, two options with the recommended one first, each saying what it changes, and typed text allowed so the answer can carry instructions. The card is the first thing the user reads, before any prose of yours, so the question itself states what you propose and why in a sentence or two; a question that is only the yes-or-no leaves them guessing what it is. Ask this way only where you would otherwise have stopped and waited; never to confirm work already asked for.",
   "An answer to a question of yours can carry typed text beside the option picked, and the text outranks the pick. Text that doubts the pick, asks you something or says the user cannot decide is not a yes: answer it in prose and change nothing until they have decided. Text that only adds detail to the pick is an instruction for carrying it out.",
   "When referencing a file in chat, use a Markdown link whose target is its absolute path, with an optional `:line`; Toyon opens it in the built-in editor, whether it is in this worktree or anywhere else on this machine. A folder, a URL route or a command is not a file: name it in backticks, never as a link.",
-  "`@some/path` in a message means read that file or directory first; `@changes` means this worktree's uncommitted files, which `git status` lists.",
+  "`@some/path` in a message means read that file or directory first; `@changes` means this worktree's uncommitted files, which `git status` lists; `@<branch>` names another worktree of this project, and the context attached to the message says where its chat is on disk.",
   '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, teardown (optional) runs once when a worktree is removed, 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; timeouts (optional) gives setup, check and commit each a ceiling as a duration like "30m" (ten minutes each when unset), for a suite that runs longer. A settings.local.json beside it (toyon.local.json at the root) holds one person\'s overrides and is never committed. Both files may carry comments and trailing commas; leave any you find.',
   "Toyon runs those commands itself in every worktree, and the user watches the result live in a preview beside this chat, so never start a dev server or open a browser of your own to check your work. Each message says where this worktree's preview answers; fetch a page from there when you want to see it.",
   "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.",
@@ -15748,7 +15938,7 @@ function fixPrompt(f) {
     case "hook":
       return hookFixPrompt(f.hook);
     case "conflict":
-      return conflictFixPrompt(f.base, f.how, !!f.step);
+      return conflictFixPrompt(f.base, f.how, !!f.step, f.carried);
     case "check":
       return checkFixPrompt(f.command);
     case "command":
@@ -15763,6 +15953,8 @@ function fixWhy(f) {
     case "hook":
       return `the ${f.hook} hook refused the ${f.hook.includes("push") ? "push" : "commit"}`;
     case "conflict":
+      if (f.carried)
+        return `the uncommitted changes conflict with ${f.base}`;
       return f.how === "rebase" ? `the branch needs a rebase onto ${f.base}` : `the branch needs ${f.base} merged in`;
     case "check":
       return "the check failed";
@@ -15793,8 +15985,12 @@ function hookFixPrompt(hook) {
     "Do not skip the hook, do not edit it or its configuration to get past it, and do not commit: Toyon runs the check when your turn ends, and the user lands from there."
   ].join(" ");
 }
-function conflictFixPrompt(base, how, shown) {
+function conflictFixPrompt(base, how, shown, carried) {
   const ask = how === "rebase" ? `Rebase this branch onto ${base} and resolve the conflicts, keeping any uncommitted changes, then verify the app still works.` : `Merge ${base} into this branch, resolve the conflicts and commit the merge, then verify the app still works.`;
+  if (carried) {
+    const where = carried.length ? `, in ${carried.join(", ")}` : "";
+    return `${ask} The branch's own commits take ${base} cleanly; the conflicts are in the uncommitted changes${where}.`;
+  }
   return shown ? `${ask} What git printed when Toyon tried is attached below.` : ask;
 }
 function checkFixPrompt(command) {
@@ -15873,6 +16069,17 @@ function handoffAskPrompt(repo, text) {
 function handoffLandedContext(title, project, url) {
   return `The work this worktree handed off to ${project}, "${title}", has landed there${url ? ` (${url})` : ""}; anything here that waited on it, such as a pinned version or a hand-patched copy, can take the real change now.`;
 }
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function worktreeContext(text, siblings) {
+  const out = [];
+  for (const s of siblings) {
+    const named = new RegExp(`(^|\\s)@${escapeRegExp(s.branch)}(?=$|[\\s.,;:!?)\\]}'"])`);
+    if (!named.test(text))
+      continue;
+    out.push(`@${s.branch} is the worktree "${s.title}" in this project. Its chat is at ${s.transcript}, one JSON object per line: a "user-message" event is what the person wrote, the "text-delta" events after it are the agent's reply, and the rest is tool activity.`);
+  }
+  return out;
+}
 function ambientBlock(paragraphs) {
   const said = paragraphs.filter((p) => !!p);
   if (said.length === 0)
@@ -16811,7 +17018,13 @@ class AcpSession {
     this.emit({ type: "turn-end", stopReason: mapStopReason(res.stopReason), ts: Date.now() });
   }
   contextFor(item) {
-    return ambientBlock([...item.context ?? [], this.d.preview?.(), this.d.pageErrors?.(), ...this.landedSince()]);
+    return ambientBlock([
+      ...item.context ?? [],
+      ...this.d.mentioned?.(item.text) ?? [],
+      this.d.preview?.(),
+      this.d.pageErrors?.(),
+      ...this.landedSince()
+    ]);
   }
   landedSince() {
     const entries = this.log.entries;
@@ -18574,6 +18787,11 @@ function defaultAgent(wt, d, preview, onProcess) {
     cwd: wt.path,
     preview: () => previewContext(preview()),
     pageErrors: () => d.pageErrors?.(wt.id),
+    mentioned: (text) => worktreeContext(text, d.state.worktrees.filter((w) => w.repoId === wt.repoId && w.id !== wt.id && w.kind === "worktree").map((w) => ({
+      branch: w.branch,
+      title: w.title,
+      transcript: transcriptPathFor(d.paths.transcriptsDir, w.id)
+    }))),
     onProcess,
     spec,
     connect: (app, spec, prepared) => spawnAcp(app, d.agents.launch(spec, prepared), wt.path, wt.id),
@@ -20447,13 +20665,14 @@ class KeepAwake {
 import { existsSync as existsSync16 } from "fs";
 import { homedir as homedir6 } from "os";
 var PROMPTS = {
-  location: "Choose where the new project goes",
-  open: "Choose a project folder to open"
+  location: { prompt: "Choose where the new project goes", pick: "folder" },
+  open: { prompt: "Choose a project folder to open", pick: "folder" },
+  file: { prompt: "Choose a file to open", pick: "file" }
 };
-var SCRIPT = [
+var script = (pick) => [
   "on run argv",
   "activate",
-  "POSIX path of (choose folder with prompt (item 1 of argv) default location (POSIX file (item 2 of argv)))",
+  `POSIX path of (choose ${pick} with prompt (item 1 of argv) default location (POSIX file (item 2 of argv)))`,
   "end run"
 ];
 function folderDialog() {
@@ -20464,7 +20683,8 @@ function folderDialog() {
     const typed = start === "~" || start.startsWith("~/") ? `${homedir6()}${start.slice(1)}` : start;
     const from = typed.startsWith("/") && existsSync16(typed) ? typed : homedir6();
     cancelled = false;
-    const p = Bun.spawn(["osascript", ...SCRIPT.flatMap((line) => ["-e", line]), PROMPTS[purpose], from], {
+    const { prompt, pick } = PROMPTS[purpose];
+    const p = Bun.spawn(["osascript", ...script(pick).flatMap((line) => ["-e", line]), prompt, from], {
       stdout: "pipe",
       stderr: "pipe",
       stdin: "ignore"
@@ -20485,7 +20705,7 @@ function folderDialog() {
   return {
     choose(start, purpose) {
       if (process.platform !== "darwin") {
-        return Promise.reject(new UserError("choosing a folder in Finder is only available on macOS"));
+        return Promise.reject(new UserError(`choosing a ${PROMPTS[purpose].pick} in Finder is only available on macOS`));
       }
       if (!open) {
         open = ask(start, purpose).finally(() => {
@@ -20933,8 +21153,21 @@ class RemoteSwitch {
 
 // ../daemon/src/core/restart.ts
 import { spawn as spawn4 } from "child_process";
-import { openSync } from "fs";
 import { homedir as homedir7 } from "os";
+
+// ../shared/src/logfile.ts
+import { chmodSync, existsSync as existsSync18, openSync, renameSync as renameSync3, statSync as statSync6 } from "fs";
+var LOG_ROTATE_BYTES = 10 * 1024 * 1024;
+var previousLog = (path) => `${path}.1`;
+function openLog(path, maxBytes = LOG_ROTATE_BYTES) {
+  if (existsSync18(path) && statSync6(path).size > maxBytes)
+    renameSync3(path, previousLog(path));
+  const fd = openSync(path, "a", 384);
+  chmodSync(path, 384);
+  return fd;
+}
+
+// ../daemon/src/core/restart.ts
 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" };
@@ -20952,7 +21185,7 @@ async function replacementRuns() {
   };
 }
 function respawn(logFile) {
-  const logFd = openSync(logFile, "a");
+  const logFd = openLog(logFile);
   const child = spawn4(process.execPath, process.argv.slice(1), {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -21095,7 +21328,7 @@ class SelfWatch {
 
 // ../daemon/src/core/state.ts
 import { randomBytes as randomBytes6 } from "crypto";
-import { existsSync as existsSync18, readFileSync as readFileSync12, renameSync as renameSync3, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync12, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "fs";
 var TRUSTED_MAX = 16;
 var DAEMON_GROUPS = "daemon";
 var GROUPS_SAVE_MS = 250;
@@ -21104,7 +21337,7 @@ var empty = { repos: [], worktrees: [], sessions: {} };
 function loadState(paths) {
   ensureDirs(paths);
   const STATE_FILE = paths.stateFile;
-  if (!existsSync18(STATE_FILE))
+  if (!existsSync19(STATE_FILE))
     return structuredClone(empty);
   let raw;
   try {
@@ -21151,12 +21384,12 @@ function loadState(paths) {
 function saveState(paths, state) {
   const tmp = `${paths.stateFile}.tmp`;
   writeFileSync8(tmp, JSON.stringify(state, null, 2));
-  renameSync3(tmp, paths.stateFile);
+  renameSync4(tmp, paths.stateFile);
 }
 function loadOrCreateToken(paths) {
   ensureDirs(paths);
   const TOKEN_FILE = paths.tokenFile;
-  if (existsSync18(TOKEN_FILE))
+  if (existsSync19(TOKEN_FILE))
     return readFileSync12(TOKEN_FILE, "utf8").trim();
   const token = randomBytes6(32).toString("hex");
   writeFileSync8(TOKEN_FILE, token, { mode: 384 });
@@ -21505,7 +21738,7 @@ class Tailnet {
   }
   async start() {
     await this.refresh();
-    this.timer = setInterval(() => void this.refresh(), READINESS_EVERY_MS);
+    this.timer = setInterval(() => fireAndForget("tailscale", this.refresh(), "tailscale readiness"), READINESS_EVERY_MS);
     this.timer.unref?.();
   }
   stop() {
@@ -21564,7 +21797,10 @@ class Tailnet {
     const now = (this.d.now ?? Date.now)();
     if (this.status === null || fresh || now - this.statusAt > STATUS_FRESH_MS) {
       this.statusAt = now;
-      this.status = ts(["status", "--json"]).then((r) => r.ok ? r.out : r.out || r.err);
+      this.status = ts(["status", "--json"]).then((r) => r.ok ? r.out : r.out || r.err, (e) => {
+        log.warn("tailscale", "could not run tailscale status", e);
+        return "";
+      });
     }
     return this.status;
   }
@@ -22191,7 +22427,7 @@ async function loadProjectTypescript(root) {
 }
 
 // ../daemon/src/drafts/store.ts
-import { existsSync as existsSync19, readFileSync as readFileSync13, renameSync as renameSync4, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync13, renameSync as renameSync5, writeFileSync as writeFileSync9 } from "fs";
 var SAVE_DELAY_MS = 1000;
 
 class DraftStore {
@@ -22328,7 +22564,7 @@ class DraftStore {
   }
 }
 function readRecord(file) {
-  if (!existsSync19(file))
+  if (!existsSync20(file))
     return [];
   try {
     const raw = JSON.parse(readFileSync13(file, "utf8"));
@@ -22342,7 +22578,7 @@ function writeAtomic(file, value) {
   const tmp = `${file}.tmp`;
   try {
     writeFileSync9(tmp, JSON.stringify(value));
-    renameSync4(tmp, file);
+    renameSync5(tmp, file);
   } catch (e) {
     log.error("drafts", `could not write ${file}`, e);
   }
@@ -22588,7 +22824,7 @@ import { stat as stat3 } from "fs/promises";
 import { basename as basename6, resolve as resolve7 } from "path";
 
 // ../daemon/src/repos/browse.ts
-import { existsSync as existsSync20, statSync as statSync6 } from "fs";
+import { existsSync as existsSync21, statSync as statSync7 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname6, join as join16 } from "path";
@@ -22605,7 +22841,7 @@ function holdsNothing(names) {
 }
 async function describeFolder(abs) {
   const path = collapseTilde(abs);
-  if (existsSync20(join16(abs, ".git")))
+  if (existsSync21(join16(abs, ".git")))
     return { path, kind: "project" };
   try {
     return { path, kind: holdsNothing(await readdir(abs)) ? "empty" : "folder" };
@@ -22613,17 +22849,21 @@ async function describeFolder(abs) {
     return { path, kind: "folder" };
   }
 }
-var NOWHERE = { exists: false, isDir: false, isRepo: false, parentExists: false };
+var NOWHERE = { exists: false, isDir: false, isRepo: false, isFile: false, parentExists: false };
 function describe2(typed, parent) {
   let isDir = false;
+  let isFile = false;
   try {
-    isDir = statSync6(typed).isDirectory();
+    const st = statSync7(typed);
+    isDir = st.isDirectory();
+    isFile = st.isFile();
   } catch {}
   return {
-    exists: existsSync20(typed),
+    exists: existsSync21(typed),
     isDir,
-    isRepo: isDir && existsSync20(join16(typed, ".git")),
-    parentExists: existsSync20(parent)
+    isRepo: isDir && existsSync21(join16(typed, ".git")),
+    isFile,
+    parentExists: existsSync21(parent)
   };
 }
 async function browsePath(raw) {
@@ -22634,25 +22874,37 @@ async function browsePath(raw) {
   const dir = listing ? typed : dirname6(typed);
   const prefix = listing ? "" : typed.slice(dir.length).replace(/^\//, "").toLowerCase();
   const target = describe2(listing ? typed.replace(/\/+$/, "") : typed, dir);
-  let names;
+  let found;
   try {
-    const found = await readdir(dir, { withFileTypes: true });
-    names = found.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
+    const listed = await readdir(dir, { withFileTypes: true });
+    found = listed.map((e) => ({
+      name: e.name,
+      isFile: e.isSymbolicLink() ? isFileAt(join16(dir, e.name)) : e.isFile() ? true : e.isDirectory() ? false : null
+    })).filter((e) => e.isFile !== null);
   } catch {
     return { entries: [], target };
   }
   const entries = [];
-  for (const name of names) {
+  for (const { name, isFile } of found) {
     if (name.startsWith(".") && !prefix.startsWith("."))
       continue;
     if (!name.toLowerCase().startsWith(prefix))
       continue;
     const abs = join16(dir, name);
-    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync20(join16(abs, ".git")) });
+    entries.push({ path: collapseTilde(abs), name, isRepo: !isFile && existsSync21(join16(abs, ".git")), isFile });
   }
-  entries.sort((a, b) => a.isRepo !== b.isRepo ? a.isRepo ? -1 : 1 : a.name.localeCompare(b.name));
+  const rank = (e) => e.isRepo ? 0 : e.isFile ? 2 : 1;
+  entries.sort((a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name));
   return { entries: entries.slice(0, MAX_ENTRIES), target };
 }
+function isFileAt(abs) {
+  try {
+    const st = statSync7(abs);
+    return st.isFile() ? true : st.isDirectory() ? false : null;
+  } catch {
+    return null;
+  }
+}
 
 // ../daemon/src/files/content.ts
 function versionOf(bytes) {
@@ -22855,20 +23107,20 @@ async function numstat(worktreePath, ...range) {
   const r = await git(worktreePath, "diff", "--numstat", "--no-renames", ...range);
   return r.ok ? parseNumstat(r.out) : new Map;
 }
-async function untrackedLines(worktreePath, file) {
+async function untrackedLines(worktreePath, file, budget) {
   try {
     const f = Bun.file(join17(worktreePath, file));
-    if (f.size > 2000000)
+    if (f.size > 2000000 || f.size > budget.left)
       return {};
+    budget.left -= f.size;
     const buf = new Uint8Array(await f.arrayBuffer());
     if (buf.subarray(0, 8000).includes(0))
       return {};
     if (buf.length === 0)
       return { add: 0, del: 0 };
     let n = 0;
-    for (const b of buf)
-      if (b === 10)
-        n++;
+    for (let i = buf.indexOf(10);i !== -1; i = buf.indexOf(10, i + 1))
+      n++;
     if (buf[buf.length - 1] !== 10)
       n++;
     return { add: n, del: 0 };
@@ -22877,16 +23129,38 @@ async function untrackedLines(worktreePath, file) {
   }
 }
 var MAX_UNTRACKED_COUNTED = 500;
-async function statusFilesWithCounts(worktreePath) {
-  const { files, folded } = await readStatus(worktreePath, []);
+var UNTRACKED_BYTES_MAX = 16 * 1024 * 1024;
+function statusEntries(worktreePath) {
+  return readStatus(worktreePath, []);
+}
+async function countEntries(worktreePath, files, folded, bytesMax = UNTRACKED_BYTES_MAX) {
+  const out = new Map;
   if (files.length === 0)
-    return files;
-  const counts = files.some((f) => f.xy !== "??") ? await numstat(worktreePath, "HEAD") : new Map;
-  const countUntracked = files.filter((f) => f.xy === "??").length <= MAX_UNTRACKED_COUNTED;
-  return Promise.all(files.map(async (f) => ({
-    ...f,
-    ...folded.has(f.path) ? {} : f.xy === "??" ? countUntracked ? await untrackedLines(worktreePath, f.path) : {} : counts.get(f.path) ?? {}
-  })));
+    return out;
+  const tracked = files.some((f) => f.xy !== "??" && !folded.has(f.path));
+  const counts = tracked ? await numstat(worktreePath, "HEAD") : new Map;
+  const untracked = files.filter((f) => f.xy === "??");
+  const countUntracked = untracked.length <= MAX_UNTRACKED_COUNTED;
+  const budget = { left: bytesMax };
+  for (const f of files) {
+    if (folded.has(f.path)) {
+      if (f.add !== undefined || f.del !== undefined)
+        out.set(f.path, { add: f.add, del: f.del });
+      continue;
+    }
+    if (f.xy !== "??") {
+      const c = counts.get(f.path);
+      if (c)
+        out.set(f.path, c);
+      continue;
+    }
+    if (!countUntracked)
+      continue;
+    const c = await untrackedLines(worktreePath, f.path, budget);
+    if (c.add !== undefined)
+      out.set(f.path, c);
+  }
+  return out;
 }
 async function committedFiles(worktreePath, defaultBr) {
   const base = await git(worktreePath, "merge-base", "HEAD", defaultBr);
@@ -23209,6 +23483,20 @@ async function viteLineOffset(worktreePath, path, target) {
 
 // ../daemon/src/files/service.ts
 var SEARCH_MAX = 300;
+var SEARCH_PER_FILE = 20;
+var HIT_TEXT_MAX = 200;
+function parseGrepRow(row) {
+  const a = row.indexOf("\x00");
+  if (a < 0)
+    return null;
+  const b = row.indexOf("\x00", a + 1);
+  if (b < 0)
+    return null;
+  const line = Number(row.slice(a + 1, b));
+  if (!Number.isInteger(line) || line < 1)
+    return null;
+  return { path: row.slice(0, a), line, text: row.slice(b + 1) };
+}
 var FIND_ROWS_MAX = 5000;
 var NOT_WHERE_WRITTEN = [
   ":!*.css",
@@ -23282,6 +23570,7 @@ class FileService {
     this.runtime = runtime;
     this.readable = readable;
   }
+  searches = new Map;
   require(worktreeId) {
     const r = this.readable(worktreeId);
     if (!r)
@@ -23361,37 +23650,73 @@ class FileService {
     ]);
     return parseListing(staged.out, untracked.out, deleted.out, ignored.out);
   }
-  async search(worktreeId, query) {
+  async search(worktreeId, query, asker) {
     const { path: cwd } = this.require(worktreeId);
     const q = query.trim();
+    if (q.length < 2)
+      return { hits: [], truncated: false };
+    this.searches.get(asker)?.abort();
+    const ctl = new AbortController;
+    this.searches.set(asker, ctl);
     const hits = [];
     let truncated = false;
-    if (q.length < 2)
-      return { hits, truncated };
-    const r = await run(GIT, ["grep", "-n", "-I", "-i", "-F", "--untracked", "--no-color", `--max-count=${SEARCH_MAX}`, "-e", q, "--"], cwd);
-    for (const row of r.rawOut.split(`
-`)) {
-      if (!row)
-        continue;
-      const m = /^(.+?):(\d+):(.*)$/.exec(row);
-      if (!m)
-        continue;
-      if (hits.length >= SEARCH_MAX) {
-        truncated = true;
-        break;
-      }
-      hits.push({ path: m[1], line: Number(m[2]), text: m[3].trim().slice(0, 200) });
+    let inFile = "";
+    let inFileRows = 0;
+    try {
+      await runRows(GIT, [
+        "grep",
+        "-n",
+        "-z",
+        "-I",
+        "-i",
+        "-F",
+        "--untracked",
+        "--no-color",
+        `--max-count=${SEARCH_PER_FILE + 1}`,
+        "-e",
+        q,
+        "--"
+      ], cwd, {
+        signal: ctl.signal,
+        onRow: (row) => {
+          const hit = parseGrepRow(row);
+          if (!hit)
+            return;
+          if (hit.path !== inFile) {
+            inFile = hit.path;
+            inFileRows = 0;
+          }
+          if (++inFileRows > SEARCH_PER_FILE) {
+            truncated = true;
+            return;
+          }
+          if (hits.length >= SEARCH_MAX) {
+            truncated = true;
+            return false;
+          }
+          hits.push({ ...hit, text: hit.text.trim().slice(0, HIT_TEXT_MAX) });
+        }
+      });
+    } finally {
+      if (this.searches.get(asker) === ctl)
+        this.searches.delete(asker);
     }
-    return { hits, truncated };
+    return ctl.signal.aborted ? null : { hits, truncated };
+  }
+  stopSearch(asker) {
+    this.searches.get(asker)?.abort();
+    this.searches.delete(asker);
   }
   async findElement(worktreeId, element) {
     const { path: cwd } = this.require(worktreeId);
     const needles = needlesOf(element);
     if (!needles.length)
       return { hits: [], sure: false };
-    const r = await run(GIT, [
+    const rows = [];
+    await runRows(GIT, [
       "grep",
       "-n",
+      "-z",
       "-I",
       "-F",
       "--untracked",
@@ -23400,17 +23725,14 @@ class FileService {
       ...needles.flatMap((n) => ["-e", n.text]),
       "--",
       ...NOT_WHERE_WRITTEN
-    ], cwd);
-    const rows = [];
-    for (const row of r.rawOut.split(`
-`)) {
-      const m = /^(.+?):(\d+):(.*)$/.exec(row);
-      if (!m)
-        continue;
-      rows.push({ path: m[1], line: Number(m[2]), text: m[3] });
-      if (rows.length >= FIND_ROWS_MAX)
-        break;
-    }
+    ], cwd, {
+      onRow: (row) => {
+        const hit = parseGrepRow(row);
+        if (hit)
+          rows.push(hit);
+        return rows.length < FIND_ROWS_MAX;
+      }
+    });
     return rankElementSources(element, rows);
   }
   async changedRanges(worktreeId, path) {
@@ -23459,12 +23781,13 @@ class OpenService {
     if (st.isDirectory()) {
       if (!await isGitRepo(path))
         throw new UserError(`${raw} is not a git repository: open one, or a file`);
-      return { kind: "repo", repoId: (await this.d.register(path)).id };
+      return { kind: "repo", repoId: (await this.d.register(path)).id, delivered: false };
     }
     const opened = await this.openFile(raw, path, st);
-    this.pending.push({ opened, at: this.now() });
+    const entry = { opened, at: this.now() };
+    this.pending.push(entry);
     this.d.hub.emit("opened", opened);
-    return opened;
+    return { ...opened, delivered: !this.pending.includes(entry) };
   }
   async file(raw) {
     const { path, st } = await this.locate(raw);
@@ -23892,7 +24215,7 @@ class AfterLand {
 }
 
 // ../daemon/src/repos/registry.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync7, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync7, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir10 } from "os";
 import { basename as basename8, dirname as dirname8, join as join21 } from "path";
 
@@ -23905,7 +24228,7 @@ async function resolveBase(repoPath, defaultBranch, route) {
 }
 
 // ../daemon/src/repos/config.ts
-import { closeSync, existsSync as existsSync21, openSync as openSync2, readdirSync as readdirSync7, readFileSync as readFileSync14, readSync, statSync as statSync7 } from "fs";
+import { closeSync, existsSync as existsSync22, openSync as openSync2, readdirSync as readdirSync7, readFileSync as readFileSync14, readSync, statSync as statSync8 } from "fs";
 import { join as join18 } from "path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
@@ -25270,7 +25593,7 @@ function applyEdits(text, edits) {
 
 // ../daemon/src/repos/config.ts
 var PLACES = [CONFIG_FILES.folder, CONFIG_FILES.root];
-var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync21(join18(repoPath, rel)));
+var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync22(join18(repoPath, rel)));
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function parseSettings(text) {
   const errors = [];
@@ -25355,7 +25678,7 @@ function configTarget(repoPath, made) {
 function configBody(repoPath, rel, config) {
   const place = PLACES.find((p) => p.local === rel);
   const abs = place && join18(repoPath, place.shared);
-  if (!abs || !existsSync21(abs))
+  if (!abs || !existsSync22(abs))
     return config;
   let shared;
   try {
@@ -25403,7 +25726,7 @@ function detectConfig(repoPath) {
   if (explicit)
     log.warn("config", `${repoPath}: ${explicit.reason}; detecting instead`);
   const pkgPath = join18(repoPath, "package.json");
-  if (existsSync21(pkgPath)) {
+  if (existsSync22(pkgPath)) {
     const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
     const runner = detectRunner(repoPath, pkg.packageManager);
@@ -25425,7 +25748,7 @@ function detectConfig(repoPath) {
       };
     }
   }
-  if (existsSync21(join18(repoPath, "start.sh"))) {
+  if (existsSync22(join18(repoPath, "start.sh"))) {
     return { config: { run: { app: "./start.sh" } }, needsSetup: true, from: "start.sh" };
   }
   const assumed = assumeNothingToRun(repoPath);
@@ -25468,7 +25791,7 @@ function assumeNothingToRun(repoPath) {
   return marker && !servesPage(repoPath) ? marker : undefined;
 }
 function markerIn(repoPath) {
-  const named = NO_PAGE_MARKERS.find((f) => existsSync21(join18(repoPath, f)));
+  const named = NO_PAGE_MARKERS.find((f) => existsSync22(join18(repoPath, f)));
   if (named)
     return named;
   let entries;
@@ -25480,7 +25803,7 @@ function markerIn(repoPath) {
   return entries.find((f) => NO_PAGE_EXTENSIONS.some((ext) => f.endsWith(ext)));
 }
 function servesPage(repoPath) {
-  if (WEB_FILES.some((f) => existsSync21(join18(repoPath, f))))
+  if (WEB_FILES.some((f) => existsSync22(join18(repoPath, f))))
     return true;
   if (/^web:/m.test(head(join18(repoPath, "Procfile"))))
     return true;
@@ -25517,7 +25840,7 @@ function mentions(text, name) {
   return new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i").test(text);
 }
 function head(path) {
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return "";
   try {
     const fd = openSync2(path, "r");
@@ -25558,7 +25881,7 @@ function isLocalDatabase(url) {
 }
 function detectServices(repoPath) {
   const out = {};
-  const compose = COMPOSE_FILES.find((f) => existsSync21(join18(repoPath, f)));
+  const compose = COMPOSE_FILES.find((f) => existsSync22(join18(repoPath, f)));
   if (compose)
     out.compose = compose;
   for (const file of ENV_FILES) {
@@ -25586,7 +25909,7 @@ function inferPaths(cmd, repoPath, depth = 1) {
       return;
     let dir = false;
     try {
-      dir = statSync7(join18(repoPath, clean)).isDirectory();
+      dir = statSync8(join18(repoPath, clean)).isDirectory();
     } catch {
       return;
     }
@@ -25597,21 +25920,21 @@ function inferPaths(cmd, repoPath, depth = 1) {
     const t = tokens[i];
     if (t === "cd") {
       const dir = tokens[i + 1];
-      if (dir && !dir.startsWith("-") && existsSync21(join18(repoPath, dir)))
+      if (dir && !dir.startsWith("-") && existsSync22(join18(repoPath, dir)))
         add(dir);
       continue;
     }
     if (t.startsWith("-") || t.startsWith("$"))
       continue;
     const mod = /^([A-Za-z_]\w*)(?:\.\w+)*:\w+$/.exec(t);
-    if (mod?.[1] && existsSync21(join18(repoPath, mod[1]))) {
+    if (mod?.[1] && existsSync22(join18(repoPath, mod[1]))) {
       add(mod[1]);
       continue;
     }
     const rel = t.replace(/^\.\//, "");
     if (rel.startsWith("/") || rel.startsWith("..") || rel.includes("="))
       continue;
-    if (!existsSync21(join18(repoPath, rel)))
+    if (!existsSync22(join18(repoPath, rel)))
       continue;
     add(rel);
     if (depth > 0 && rel.endsWith(".sh")) {
@@ -25638,9 +25961,9 @@ function procCommand(runner, script, body) {
   return `${base}${runner === "npm" ? " --" : ""} ${flag}`;
 }
 function detectPages(repoPath, scripts, runner) {
-  if (!scripts.build || !existsSync21(join18(repoPath, "functions")))
+  if (!scripts.build || !existsSync22(join18(repoPath, "functions")))
     return null;
-  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join18(repoPath, f)).find((f) => existsSync21(f));
+  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join18(repoPath, f)).find((f) => existsSync22(f));
   if (!cfg)
     return null;
   const out = readFileSync14(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
@@ -25649,17 +25972,17 @@ function detectPages(repoPath, scripts, runner) {
   return { web: `${runner} run build && npx wrangler pages dev ${out} --ip 127.0.0.1 --port $PORT` };
 }
 function detectRunner(repoPath, packageManager) {
-  if (existsSync21(join18(repoPath, "bun.lock")) || existsSync21(join18(repoPath, "bun.lockb")))
+  if (existsSync22(join18(repoPath, "bun.lock")) || existsSync22(join18(repoPath, "bun.lockb")))
     return "bun";
-  if (existsSync21(join18(repoPath, "pnpm-lock.yaml")))
+  if (existsSync22(join18(repoPath, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync21(join18(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
+  if (existsSync22(join18(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
     return "yarn";
   return "npm";
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync22, realpathSync as realpathSync2, statSync as statSync8 } from "fs";
+import { existsSync as existsSync23, realpathSync as realpathSync2, statSync as statSync9 } from "fs";
 import { appendFile as appendFile2, mkdir as mkdir3, rm as rm2 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { dirname as dirname7, join as join19, resolve as resolve8 } from "path";
@@ -25674,13 +25997,13 @@ function planProject(opts, home = homedir9()) {
   const first = firstProjectsFolder(opts.parent, home);
   const parent = first ?? resolveParent(opts.parent);
   const dir = join19(parent, opts.name.trim());
-  if (existsSync22(dir))
+  if (existsSync23(dir))
     throw new UserError(`${dir} already exists`);
   return { parent, dir, makeParent: first !== null };
 }
 function firstProjectsFolder(raw, home) {
   const typed = expandTilde(raw.trim()).replace(/\/+$/, "");
-  if (typed !== join19(home, PROJECTS_FOLDER) || existsSync22(typed) || !existsSync22(home))
+  if (typed !== join19(home, PROJECTS_FOLDER) || existsSync23(typed) || !existsSync23(home))
     return null;
   return join19(realpathSync2(home), PROJECTS_FOLDER);
 }
@@ -25690,10 +26013,10 @@ function planInPlace(opts) {
     throw new UserError(`${opts.name} is not a folder name`);
   }
   const typed = join19(resolveParent(opts.parent), name);
-  if (!existsSync22(typed) || !statSync8(typed).isDirectory())
+  if (!existsSync23(typed) || !statSync9(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
-  if (existsSync22(join19(dir, ".git")))
+  if (existsSync23(join19(dir, ".git")))
     throw new UserError(`${dir} is already a project; open it instead`);
   return { parent: dirname7(dir), dir, makeParent: false };
 }
@@ -25701,9 +26024,9 @@ function resolveParent(raw) {
   const typed = expandTilde(raw.trim());
   if (!typed.startsWith("/"))
     throw new UserError(`${raw} is not a folder path`);
-  if (!existsSync22(typed))
+  if (!existsSync23(typed))
     throw new UserError(`${raw} does not exist; make it first`);
-  if (!statSync8(typed).isDirectory())
+  if (!statSync9(typed).isDirectory())
     throw new UserError(`${raw} is not a folder`);
   return realpathSync2(typed);
 }
@@ -25818,7 +26141,7 @@ async function ok(p, what) {
 }
 
 // ../daemon/src/repos/watcher.ts
-import { existsSync as existsSync23, watch } from "fs";
+import { existsSync as existsSync24, watch } from "fs";
 import { basename as basename7, join as join20 } from "path";
 function watchDefaultBranch(repoPath, branch, onMove) {
   const last = { local: null, upstream: null };
@@ -25883,11 +26206,11 @@ function watchDefaultBranch(repoPath, branch, onMove) {
     let mid = null;
     const armInner = () => {
       inner?.close();
-      inner = existsSync23(mine) ? tryWatch(mine) : null;
+      inner = existsSync24(mine) ? tryWatch(mine) : null;
     };
     const armMid = () => {
       mid?.close();
-      mid = existsSync23(remotes) ? tryWatch(remotes, (_event, filename) => {
+      mid = existsSync24(remotes) ? tryWatch(remotes, (_event, filename) => {
         if (!filename || filename === remote.out)
           armInner();
         schedule();
@@ -25981,7 +26304,7 @@ function watchConfigFile(repoPath, onChange) {
   const armInner = () => {
     inner?.close();
     inner = null;
-    if (!existsSync23(dir))
+    if (!existsSync24(dir))
       return;
     try {
       inner = watch(dir, (_event, filename) => {
@@ -26035,7 +26358,7 @@ class RepoRegistry {
   }
   async boot() {
     const { state } = this.d;
-    const gone = state.worktrees.filter((wt) => !existsSync24(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
+    const gone = state.worktrees.filter((wt) => !existsSync25(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
     for (const wt of gone)
       await this.d.worktrees.forgetGone(wt);
     for (const repo of state.repos) {
@@ -26103,7 +26426,7 @@ class RepoRegistry {
       return `${repo.name} is set up now`;
     if (main.promptedAt || main.lastTurn)
       return `${repo.name} has a chat now`;
-    if (existsSync24(join21(repo.path, ".claude")))
+    if (existsSync25(join21(repo.path, ".claude")))
       return `an agent has already run in ${repo.name}`;
     if ((await statusFiles(repo.path)).length > 0 || !await treeEmpty(repo.path)) {
       return `${repo.name} has files in it now`;
@@ -26184,7 +26507,7 @@ class RepoRegistry {
   }
   async register(rawPath, made) {
     const path = expandTilde(rawPath);
-    if (!existsSync24(path))
+    if (!existsSync25(path))
       throw new UserError(`${path} does not exist`);
     if (!await isGitRepo(path))
       throw new UserError(`${path} is not a git repository`);
@@ -26258,7 +26581,7 @@ class RepoRegistry {
       throw new UserError(current.reason);
     const was = configTarget(repo.path, !!repo.made);
     const rel = configSibling(was, kind);
-    const moved = rel !== was && existsSync24(join21(repo.path, was));
+    const moved = rel !== was && existsSync25(join21(repo.path, was));
     if (moved && !(kind === "local" && await isTracked(repo.path, was))) {
       try {
         rmSync4(join21(repo.path, was));
@@ -26374,7 +26697,7 @@ class RepoRegistry {
   }
   placeConfig(repo) {
     const rel = configTarget(repo.path, !!repo.made);
-    if (isLocalConfigFile(rel) && existsSync24(join21(repo.path, rel))) {
+    if (isLocalConfigFile(rel) && existsSync25(join21(repo.path, rel))) {
       fireAndForget(repo.id, excludeFromGit(repo.path, rel), "exclude local settings");
     }
     if (repo.configFile === rel)
@@ -27450,6 +27773,14 @@ var bunFs = {
     }
   }
 };
+function scanKey(git) {
+  if (git.version !== undefined)
+    return `v${git.version}`;
+  const entries = git.files.filter((f) => isManifest(f.path) || CODE_FILE.test(f.path)).map((f) => `${f.xy}${f.path}`).sort();
+  return `${git.head ?? ""}
+${entries.join(`
+`)}`;
+}
 var signatureOf = (list) => list.map((e) => `${e.path}	${e.title ?? ""}`).join(`
 `);
 
@@ -27514,7 +27845,11 @@ class RouteService {
     if (!wt)
       return { routes: [], unseen: {} };
     const scan = this.scanFor(worktreeId, wt.path);
-    await this.routesOf(scan);
+    const key = scanKey(git);
+    if (!scan.routes || scan.key !== key) {
+      scan.key = key;
+      await this.routesOf(scan);
+    }
     scan.git = git;
     await this.refreshUnseen(worktreeId, scan);
     return scan.pages ?? { routes: [], unseen: {} };
@@ -27565,7 +27900,7 @@ class RouteService {
   async refreshUnseen(worktreeId, scan) {
     if (!scan.routes)
       return false;
-    const changed = scan.git ? [...scan.git.files, ...scan.git.committed ?? []] : [];
+    const changed = scan.git ? [...scan.git.files, ...scan.git.extras?.committed ?? []] : [];
     const seen = this.d.state.seenOf(worktreeId);
     const candidates = badgeCandidates(scan.routes, changed, seen?.here).slice(0, MAX_HASHED);
     const hashes = {};
@@ -27590,7 +27925,8 @@ class RouteService {
       manifests: new Map,
       code: new Map,
       git: null,
-      pages: null
+      pages: null,
+      key: null
     };
     scan.root = root;
     this.scans.delete(worktreeId);
@@ -27953,7 +28289,7 @@ function isAlive(pid) {
 }
 
 // ../daemon/src/runtime/bridge-script.ts
-import { existsSync as existsSync25, readFileSync as readFileSync15, statSync as statSync9 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync15, statSync as statSync10 } from "fs";
 var LEARNED_MAX = 8;
 
 class BridgeScript {
@@ -27983,9 +28319,9 @@ class BridgeScript {
     this.cache = null;
   }
   get() {
-    if (!existsSync25(this.path))
+    if (!existsSync26(this.path))
       return "// toyon bridge not built";
-    const s = statSync9(this.path);
+    const s = statSync10(this.path);
     const stamp = `${s.mtimeMs}:${s.size}`;
     if (this.cache && stamp === this.stamp)
       return this.cache;
@@ -28009,6 +28345,51 @@ function servedLocally(origin) {
   return h === "127.0.0.1" || h === "localhost" || h === "::1" || h === "[::1]" || h.endsWith(".localhost");
 }
 
+// ../daemon/src/server/interest.ts
+class Interest {
+  keys = new Map;
+  first = [];
+  last = [];
+  subscribe(key, id) {
+    let set = this.keys.get(id);
+    if (!set) {
+      set = new Set;
+      this.keys.set(id, set);
+    }
+    const was = set.size;
+    set.add(key);
+    if (was === 0)
+      for (const fn of this.first)
+        fn(id);
+  }
+  unsubscribe(key, id) {
+    const set = this.keys.get(id);
+    if (!set?.delete(key))
+      return;
+    if (set.size === 0) {
+      this.keys.delete(id);
+      for (const fn of this.last)
+        fn(id);
+    }
+  }
+  drop(key) {
+    for (const id of [...this.keys.keys()])
+      this.unsubscribe(key, id);
+  }
+  isSubscribed(id) {
+    return (this.keys.get(id)?.size ?? 0) > 0;
+  }
+  subscribed() {
+    return [...this.keys.keys()];
+  }
+  onFirst(fn) {
+    this.first.push(fn);
+  }
+  onLast(fn) {
+    this.last.push(fn);
+  }
+}
+
 // ../daemon/src/server/ws.ts
 import { homedir as homedir12, hostname as hostname2 } from "os";
 
@@ -28016,7 +28397,7 @@ import { homedir as homedir12, hostname as hostname2 } from "os";
 import { randomBytes as randomBytes7 } from "crypto";
 
 // ../daemon/src/agent/config.ts
-import { existsSync as existsSync26, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join23 } from "path";
 function agentConfigFiles(spec, repoPath, home = homedir11()) {
@@ -28024,7 +28405,7 @@ function agentConfigFiles(spec, repoPath, home = homedir11()) {
     id,
     label,
     path,
-    exists: existsSync26(path)
+    exists: existsSync27(path)
   });
   if (spec.id === "claude") {
     return [
@@ -28056,7 +28437,7 @@ function describeAgentConfig(spec, repoPath, home = homedir11()) {
   return { agent: spec.id, files, servers };
 }
 function readJson(path) {
-  if (!existsSync26(path))
+  if (!existsSync27(path))
     return null;
   try {
     const v = JSON.parse(readFileSync16(path, "utf8"));
@@ -28077,7 +28458,7 @@ function serversOf(raw, scope) {
   });
 }
 function codexServers(path) {
-  if (!existsSync26(path))
+  if (!existsSync27(path))
     return [];
   const out = [];
   let current = null;
@@ -28619,11 +29000,12 @@ function daylightNow(tz, at = new Date) {
 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);
+  const info = s.worktrees.readable(worktreeId) ? await s.worktrees.tree.current(worktreeId, FIRST_FRAME_WAIT_MS) : await s.worktrees.archivedStatus(worktreeId);
   if (info)
     ctx.reply({ t: "git-status", worktreeId, ...info });
   return info;
 };
+var FIRST_FRAME_WAIT_MS = 250;
 var gitAndPages = async (s, ctx, worktreeId) => {
   const info = await gitStatus(s, ctx, worktreeId);
   ctx.reply({ t: "routes", worktreeId, ...await s.routes.pages(worktreeId, info ?? { files: [] }) });
@@ -28922,8 +29304,12 @@ var handlers = {
     ctx.reply({ t: "files", worktreeId: msg.worktreeId, ...await s.files.list(msg.worktreeId) });
   },
   async search(msg, ctx, s) {
-    const { hits, truncated } = await s.files.search(msg.worktreeId, msg.query);
-    ctx.reply({ t: "search-results", worktreeId: msg.worktreeId, query: msg.query, hits, truncated });
+    const page = await s.files.search(msg.worktreeId, msg.query, ctx.socket);
+    if (page)
+      ctx.reply({ t: "search-results", worktreeId: msg.worktreeId, query: msg.query, ...page });
+  },
+  "search-stop"(_msg, ctx, s) {
+    s.files.stopSearch(ctx.socket);
   },
   async "find-element"(msg, ctx, s) {
     const { hits, sure } = await s.files.findElement(msg.worktreeId, msg.element);
@@ -29060,6 +29446,11 @@ var handlers = {
     }
     ctx.reply({ t: "folder-chosen", folder: path ? await describeFolder(path) : null });
   },
+  async "choose-file"(msg, ctx, s) {
+    const path = await s.folderDialog.choose(msg.start, "file");
+    if (path)
+      ctx.reply(openedFrame(await s.opens.file(path)));
+  },
   "cancel-folder"(_msg, _ctx, s) {
     s.folderDialog.cancel();
   },
@@ -29259,7 +29650,7 @@ async function dispatch(msg, ctx, s) {
 }
 
 // ../daemon/src/server/http.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { hostname } from "os";
 import { join as join24 } from "path";
 
@@ -29564,7 +29955,7 @@ function createFetch(opts) {
         return new Response("unauthorized", { status: 401 });
       const id = url.pathname.slice("/uploads/".length);
       const path = opts.attachments.uploads.path(id);
-      if (!path || !existsSync27(path))
+      if (!path || !existsSync28(path))
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), {
         headers: { "cache-control": IMMUTABLE, ...attachedHeaders(opts.attachments.uploads.imageType(id)) }
@@ -29577,7 +29968,7 @@ function createFetch(opts) {
       const places = worktreeId && file && !extra ? [opts.attachments.fileFor(worktreeId, file), opts.archivedAttachment(worktreeId, file)] : [];
       if (worktreeId && file)
         await opts.attachments.whenWritten(worktreeId, file);
-      const path = places.find((p) => !!p && existsSync27(p));
+      const path = places.find((p) => !!p && existsSync28(p));
       if (!path)
         return new Response("not found", { status: 404 });
       if (url.searchParams.has("where")) {
@@ -29617,7 +30008,7 @@ function createFetch(opts) {
     const rel = url.pathname === "/" ? "/index.html" : url.pathname;
     const file = join24(opts.shellDist, rel.replaceAll("..", ""));
     const hashed = rel.startsWith("/assets/");
-    if (existsSync27(file) && Bun.file(file).size > 0) {
+    if (existsSync28(file) && Bun.file(file).size > 0) {
       if (rel === "/manifest.json") {
         const { bar, ground } = opts.manifestColors();
         const manifest = { ...await Bun.file(file).json(), theme_color: bar, background_color: ground };
@@ -29637,7 +30028,7 @@ function createFetch(opts) {
     if (hashed)
       return new Response("not found", { status: 404 });
     const index = join24(opts.shellDist, "index.html");
-    if (existsSync27(index))
+    if (existsSync28(index))
       return new Response(Bun.file(index), { headers: { "cache-control": NO_STORE2 } });
     return new Response("Toyon daemon running; shell not built (run: bun run build)", { status: 200 });
   }
@@ -29780,6 +30171,11 @@ function startServer(opts) {
   };
   const metrics = () => ({
     lag,
+    lagHist,
+    gitSpawns,
+    treeReads,
+    syncHot,
+    fdLimit: limits.fdLimit || undefined,
     worktrees: {
       total: s.state.worktrees.filter((w) => w.kind !== "spare").length,
       running: s.runtime.runningCount(),
@@ -29811,24 +30207,19 @@ function startServer(opts) {
   s.hub.on("pendingChanged", () => broadcast({ t: "pending-repos", pending: s.repos.pending }));
   s.hub.on("proc", (worktreeId, proc) => broadcast({ t: "proc", worktreeId, proc }));
   s.hub.on("log", (worktreeId, proc, line, retract) => sendTo(worktreeId, retract ? { t: "log", worktreeId, proc, line, retract } : { t: "log", worktreeId, proc, line }));
+  s.hub.on("agent", (worktreeId, seq, event) => sendTo(worktreeId, { t: "agent", worktreeId, seq, event }));
   s.hub.on("queue", (worktreeId, items) => sendTo(worktreeId, { t: "queue", worktreeId, items }));
   s.hub.on("agentCommands", (worktreeId, commands) => sendTo(worktreeId, { t: "agent-commands", worktreeId, commands }));
   s.hub.on("termData", (worktreeId, stream, data) => queueTerm(worktreeId, stream, data));
   s.hub.on("termExit", (worktreeId, stream, exitCode) => sendTerm(worktreeId, stream, { t: "term-exit", worktreeId, stream, exitCode }));
-  const gitStatusTimers = new Map;
-  const refreshGitStatus = (worktreeId) => {
-    clearTimeout(gitStatusTimers.get(worktreeId));
-    gitStatusTimers.set(worktreeId, setTimeout(() => {
-      gitStatusTimers.delete(worktreeId);
-      fireAndForget(worktreeId, pushGitStatus(worktreeId), "git status after agent edit");
-    }, 150));
-  };
-  s.hub.on("agent", (worktreeId, seq, event) => {
-    sendTo(worktreeId, { t: "agent", worktreeId, seq, event });
-    if (event.type === "tool-end" || event.type === "turn-end")
-      refreshGitStatus(worktreeId);
+  s.hub.on("treeChanged", (worktreeId) => {
+    const frame = s.worktrees.tree.frame(worktreeId);
+    if (!frame)
+      return;
+    sendTo(worktreeId, { t: "git-status", worktreeId, ...frame });
+    if (frame.extras)
+      fireAndForget(worktreeId, s.routes.pages(worktreeId, frame).then((p) => sendPages(worktreeId, p)), "pages after git status");
   });
-  s.hub.on("filesChanged", refreshGitStatus);
   s.hub.on("opened", (o) => {
     if (sockets.size === 0)
       return;
@@ -29836,18 +30227,6 @@ function startServer(opts) {
     s.opens.delivered();
   });
   s.hub.on("openRefused", (message) => broadcast({ t: "error", message }));
-  const shellQuiet = new Map;
-  s.hub.on("termData", (worktreeId, stream) => {
-    if (stream !== SHELL_STREAM)
-      return;
-    clearTimeout(shellQuiet.get(worktreeId));
-    shellQuiet.set(worktreeId, setTimeout(() => {
-      shellQuiet.delete(worktreeId);
-      s.worktrees.invalidateCounts(worktreeId);
-      worktreesChanged();
-      fireAndForget(worktreeId, pushGitStatus(worktreeId), "git status after the shell went quiet");
-    }, 1500));
-  });
   const sentPages = new Map;
   const sendPages = (worktreeId, pages) => {
     const json = JSON.stringify(pages);
@@ -29856,32 +30235,12 @@ function startServer(opts) {
     sentPages.set(worktreeId, json);
     sendTo(worktreeId, { t: "routes", worktreeId, ...pages });
   };
-  const pushGitStatus = async (worktreeId) => {
-    if (![...sockets].some((ws) => ws.data.subs.has(worktreeId)))
-      return;
-    const info = await s.worktrees.gitStatus(worktreeId);
-    if (!info)
-      return;
-    sendTo(worktreeId, { t: "git-status", worktreeId, ...info });
-    sendPages(worktreeId, await s.routes.pages(worktreeId, info));
-  };
   s.hub.on("pagesChanged", (worktreeId) => {
     const pages = s.routes.cached(worktreeId);
     if (pages)
       sendPages(worktreeId, pages);
   });
-  s.hub.on("repoTick", (repoId) => {
-    worktreesChanged();
-    const subscribed = new Set;
-    for (const ws of sockets)
-      for (const id of ws.data.subs)
-        subscribed.add(id);
-    for (const id of subscribed) {
-      if (s.worktrees.readable(id)?.repoId !== repoId)
-        continue;
-      fireAndForget(id, pushGitStatus(id), "git status on ref tick");
-    }
-  });
+  s.hub.on("repoTick", () => worktreesChanged());
   const themesChanged = () => {
     const cur = s.themes.current();
     setWaitingColors({ bg: cur.colors.surface0, fg: cur.colors.text1 });
@@ -30024,8 +30383,11 @@ function startServer(opts) {
       close(ws) {
         if (ws.data.preview)
           ws.data.preview.handler.close(ws.data.preview.data);
-        else
+        else {
           s.idle.drop(ws.data);
+          s.interest.drop(ws.data);
+        }
+        s.files.stopSearch(ws.data);
         sockets.delete(ws);
         unlink(ws);
       },
@@ -30055,10 +30417,12 @@ function startServer(opts) {
             if (ws.data.subs.has(id))
               return false;
             ws.data.subs.add(id);
+            s.interest.subscribe(ws.data, id);
             return true;
           },
           unsubscribe: (id) => {
-            ws.data.subs.delete(id);
+            if (ws.data.subs.delete(id))
+              s.interest.unsubscribe(ws.data, id);
             if (ws.data.view === id) {
               ws.data.view = null;
               s.idle.view(ws.data, null);
@@ -30075,7 +30439,8 @@ function startServer(opts) {
             const key = streamKey(id, stream);
             ws.data.terms.delete(key);
             ws.data.dropped.delete(key);
-          }
+          },
+          socket: ws.data
         };
         try {
           await dispatch(parsed.msg, ctx, s);
@@ -30112,7 +30477,7 @@ function startServer(opts) {
 }
 
 // ../daemon/src/themes/store.ts
-import { existsSync as existsSync28, readdirSync as readdirSync8, readFileSync as readFileSync17, statSync as statSync10, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync8, readFileSync as readFileSync17, statSync as statSync11, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir13 } from "os";
 import { basename as basename9, dirname as dirname9, join as join25, resolve as resolve9 } from "path";
 var home = homedir13();
@@ -30234,7 +30599,7 @@ function readVscodeTheme(file, depth = 0) {
   return t;
 }
 function loadDir(dir) {
-  if (!existsSync28(dir))
+  if (!existsSync29(dir))
     return [];
   const out = [];
   for (const f of readdirSync8(dir)) {
@@ -30256,7 +30621,7 @@ function loadDir(dir) {
   return out;
 }
 function discover(dir) {
-  if (!existsSync28(dir))
+  if (!existsSync29(dir))
     return [];
   const out = [];
   let entries;
@@ -30269,7 +30634,7 @@ function discover(dir) {
     const extDir = join25(dir, name);
     const pkgFile = join25(extDir, "package.json");
     try {
-      if (!statSync10(extDir).isDirectory() || !existsSync28(pkgFile))
+      if (!statSync11(extDir).isDirectory() || !existsSync29(pkgFile))
         continue;
       const pkg = JSON.parse(readFileSync17(pkgFile, "utf8"));
       const themes = pkg.contributes?.themes;
@@ -30278,7 +30643,7 @@ function discover(dir) {
       const ext = `${pkg.publisher ?? "local"}.${pkg.name ?? name}`;
       let nls = {};
       const nlsFile = join25(extDir, "package.nls.json");
-      if (existsSync28(nlsFile)) {
+      if (existsSync29(nlsFile)) {
         try {
           nls = JSON.parse(readFileSync17(nlsFile, "utf8"));
         } catch {}
@@ -30692,7 +31057,7 @@ class BackendShare {
 
 // ../daemon/src/worktrees/cache.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync29, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync18 } from "fs";
 import { mkdir as mkdir5, readdir as readdir2, rename, rm as rm4, stat as stat4, utimes, writeFile as writeFile3 } from "fs/promises";
 import { join as join26 } from "path";
 
@@ -30725,7 +31090,7 @@ var STALE_MS = 30 * 24 * 3600000;
 var TMP = ".tmp-";
 var MANIFEST = "manifest.json";
 function defaultTools(dir) {
-  const has = (...files) => files.some((f) => existsSync29(join26(dir, f)));
+  const has = (...files) => files.some((f) => existsSync30(join26(dir, f)));
   const out = [];
   if (has("bun.lock", "bun.lockb"))
     out.push("bun --version");
@@ -30738,7 +31103,7 @@ function defaultTools(dir) {
   return out;
 }
 function withSidecars(root, rel) {
-  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync29(join26(root, n)));
+  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync30(join26(root, n)));
 }
 var entryName = (base, at) => `${base.slice(0, 12)}-${at.toString(36)}`;
 async function listEntries(familyDir) {
@@ -30754,7 +31119,7 @@ async function listEntries(familyDir) {
     if (!m?.[1] || !m[2])
       continue;
     const dir = join26(familyDir, name);
-    if (!existsSync29(join26(dir, MANIFEST)))
+    if (!existsSync30(join26(dir, MANIFEST)))
       continue;
     out.push({ dir, base: m[1], at: Number.parseInt(m[2], 36) });
   }
@@ -30792,7 +31157,7 @@ class ArtifactCache {
       }
       const restored = [];
       for (const rel of policy.paths) {
-        if (existsSync29(join26(wt.path, rel)))
+        if (existsSync30(join26(wt.path, rel)))
           continue;
         const names = withSidecars(entry.dir, rel);
         if (names.length === 0)
@@ -30833,7 +31198,7 @@ class ArtifactCache {
     let tmp;
     let slot;
     try {
-      const present = policy.paths.filter((rel) => existsSync29(join26(wt.path, rel)));
+      const present = policy.paths.filter((rel) => existsSync30(join26(wt.path, rel)));
       if (present.length === 0)
         return;
       const family = await this.family(wt, repo, policy);
@@ -31633,6 +31998,9 @@ class LandingService {
     };
   }
   async hasWork(wt) {
+    const rec = await this.d.worktrees.tree?.refresh(wt.id);
+    if (rec && rec.failedAt === undefined)
+      return rec.core.files.length > 0 || (rec.core.ahead ?? 0) > 0;
     const repo = this.d.state.requireRepo(wt.repoId);
     const files = await statusFiles(wt.path);
     if (files.length > 0)
@@ -31857,11 +32225,8 @@ class PrService {
       if (!fresh || !now || now.pr?.number !== pr.number)
         return fresh;
       this.d.worktrees.setPr(worktreeId, fresh);
-      if (fresh.state === "merged" && !prTaken(now)) {
-        const r = await this.d.worktrees.prMerged(worktreeId);
-        if (!r.ok)
-          log.info(worktreeId, `PR #${pr.number} merged; main here did not follow: ${r.message}`);
-      }
+      if (fresh.state === "merged" && !prTaken(now))
+        await this.d.worktrees.prMerged(worktreeId);
       return fresh;
     } finally {
       this.reading.delete(worktreeId);
@@ -32172,9 +32537,9 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { cpSync, existsSync as existsSync34, readFileSync as readFileSync20, rmSync as rmSync8 } from "fs";
+import { cpSync, existsSync as existsSync35, readFileSync as readFileSync20, rmSync as rmSync8 } from "fs";
 import { rm as rm5 } from "fs/promises";
-import { dirname as dirname12, join as join30 } from "path";
+import { dirname as dirname12, join as join31 } from "path";
 
 // ../daemon/src/git/archive.ts
 import { rmSync as rmSync5 } from "fs";
@@ -32298,8 +32663,8 @@ async function dropLandRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/git/land.ts
-import { existsSync as existsSync30 } from "fs";
-var STEP_TIMEOUT_MS = 10 * 60000;
+import { existsSync as existsSync31 } from "fs";
+var STEP_TIMEOUT_MS = RUN_CEILING_MS;
 function rowOf(r) {
   return r.shown && r.toolId && r.command ? { toolId: r.toolId, command: r.command, text: r.text } : undefined;
 }
@@ -32387,7 +32752,7 @@ async function setAside(worktreePath) {
   }
   return { sha: made.out, head: head.out };
 }
-async function putBack(worktreePath, defaultBr, aside, taken) {
+async function putBack(worktreePath, defaultBr, how, aside, taken) {
   let clash = null;
   if (taken.ok) {
     const applied = await git(worktreePath, "stash", "apply", aside.sha);
@@ -32411,9 +32776,12 @@ async function putBack(worktreePath, defaultBr, aside, taken) {
   if (!clash)
     return taken;
   const named = clash.length ? ` (${listed(clash)})` : "";
+  const ask = how === "rebase" ? `rebase onto ${defaultBr}` : `merge ${defaultBr}`;
   return {
     ok: false,
-    message: `the uncommitted changes here conflict with ${defaultBr}${named}: commit them first, then sync`
+    conflict: how,
+    carried: clash,
+    message: `the uncommitted changes here conflict with ${defaultBr}${named}: ask the agent to ${ask} and resolve them`
   };
 }
 var MIDWAY = [
@@ -32429,7 +32797,7 @@ async function midway(worktreePath) {
   if (!r.ok)
     return null;
   const at = r.out.split(`
-`).findIndex((file) => file && existsSync30(file));
+`).findIndex((file) => file && existsSync31(file));
   return MIDWAY[at]?.[1] ?? null;
 }
 async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = false) {
@@ -32445,11 +32813,12 @@ async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = f
   const { behind } = await aheadBehind(worktreePath, defaultBr);
   if (behind === 0)
     return { ok: true, message: `already up to date with ${defaultBr}` };
+  const how = await howToBring(worktreePath, defaultBr, own);
   const aside = carry ? await setAside(worktreePath) : null;
   if (aside && "message" in aside)
     return aside;
-  const taken = await bringIn(worktreePath, defaultBr, own, behind, w);
-  return aside ? putBack(worktreePath, defaultBr, aside, taken) : taken;
+  const taken = await bringIn(worktreePath, defaultBr, how, behind, w);
+  return aside ? putBack(worktreePath, defaultBr, how, aside, taken) : taken;
 }
 async function requireLinear(worktreePath, base) {
   const merges = await git(worktreePath, "rev-list", "--merges", "--count", `${base}..HEAD`);
@@ -32461,9 +32830,14 @@ async function requireLinear(worktreePath, base) {
     message: `the branch holds a merge commit, which landing by rebase would put on ${base}: ask the agent to rebase onto ${base} first`
   };
 }
-async function bringIn(worktreePath, defaultBr, own, behind, w) {
-  const merges = own ? await git(worktreePath, "rev-list", "--merges", "--count", `${defaultBr}..HEAD`) : null;
-  if (own && merges?.out === "0") {
+async function howToBring(worktreePath, defaultBr, own) {
+  if (!own)
+    return "merge";
+  const merges = await git(worktreePath, "rev-list", "--merges", "--count", `${defaultBr}..HEAD`);
+  return merges.out === "0" ? "rebase" : "merge";
+}
+async function bringIn(worktreePath, defaultBr, how, behind, w) {
+  if (how === "rebase") {
     w.step(`rebasing onto ${defaultBr}`);
     const r = await w.git(worktreePath, ["rebase", defaultBr]);
     if (!r.ok) {
@@ -32716,7 +33090,7 @@ async function openPr(o, w = UNWATCHED) {
   const push = await pushBranch(o.worktreePath, o.branch, w);
   if (!push.ok)
     return push;
-  w.step("opening the PR");
+  w.step("creating the PR");
   const titled = o.subject ? ["--title", o.subject, "--body", o.body ?? ""] : ["--fill"];
   const created = await gh(["pr", "create", "--head", o.branch, "--base", o.defaultBr, ...titled], o.worktreePath);
   let url = null;
@@ -32735,7 +33109,7 @@ ${created.exit}`)) {
     return { ok: false, message: `gh pr create failed: ${created.err.slice(0, 300)}` };
   const number = url ? prNumberOf(url) : null;
   if (!url || number === null)
-    return { ok: true, message: `pushed ${o.branch}; PR opened but its URL was not read` };
+    return { ok: true, message: `pushed ${o.branch}; PR created but its URL was not read` };
   let note = "";
   if (o.automerge) {
     const method = await ghMethod(o.worktreePath, o.method);
@@ -32773,7 +33147,7 @@ function compareUrl(remoteUrl, base, branch) {
 }
 
 // ../daemon/src/git/turn.ts
-import { copyFileSync, existsSync as existsSync31, rmSync as rmSync6 } from "fs";
+import { copyFileSync, existsSync as existsSync32, rmSync as rmSync6 } from "fs";
 import { join as join27 } from "path";
 var turnRef = (worktreeId, which) => `refs/toyon/turns/${worktreeId}/${which}`;
 var SNAPSHOT_SUBJECT2 = "toyon: tree at a send";
@@ -32799,7 +33173,7 @@ async function treeNow(wtPath, head, dirty) {
     const tree = await run(GIT, ["write-tree"], wtPath, env);
     return tree.ok && tree.out ? tree.out : null;
   };
-  if (!existsSync31(index))
+  if (!existsSync32(index))
     was = undefined;
   const paths = dirty && !dirty.some((f) => /[RC]/.test(f.xy)) ? dirty.map((f) => f.path) : null;
   if (was && paths && was.head === head) {
@@ -32814,9 +33188,9 @@ async function treeNow(wtPath, head, dirty) {
     }
   }
   synced.delete(wtPath);
-  if (!existsSync31(index)) {
+  if (!existsSync32(index)) {
     const own = join27(index, "..", "index");
-    if (existsSync31(own))
+    if (existsSync32(own))
       copyFileSync(own, index);
     else if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
       return null;
@@ -32897,7 +33271,7 @@ async function dropTurnRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync19, renameSync as renameSync5, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync19, renameSync as renameSync6, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "fs";
 import { basename as basename11, dirname as dirname11, join as join28 } from "path";
 class WorktreeArchive {
   dir;
@@ -32907,7 +33281,7 @@ class WorktreeArchive {
     mkdirSync8(dir, { recursive: true });
     for (const id of readdirSync9(dir)) {
       const file = this.filesOf(id).record;
-      if (!existsSync32(file))
+      if (!existsSync33(file))
         continue;
       try {
         this.records.set(id, JSON.parse(readFileSync19(file, "utf8")));
@@ -32966,7 +33340,7 @@ class WorktreeArchive {
     if (!this.records.has(id) || !isPlanPath(rel))
       return null;
     const file = join28(this.filesOf(id).plans, basename11(rel));
-    if (!existsSync32(file))
+    if (!existsSync33(file))
       return null;
     try {
       return readFileSync19(file, "utf8");
@@ -33007,7 +33381,7 @@ function summarize(r, repoId, transcript) {
   };
 }
 function lastUsage(transcript) {
-  if (!existsSync32(transcript))
+  if (!existsSync33(transcript))
     return null;
   const lines = readFileSync19(transcript, "utf8").split(`
 `);
@@ -33023,7 +33397,7 @@ function lastUsage(transcript) {
   return null;
 }
 function firstPrompt(transcript) {
-  if (!existsSync32(transcript))
+  if (!existsSync33(transcript))
     return;
   for (const line of readFileSync19(transcript, "utf8").split(`
 `)) {
@@ -33038,11 +33412,11 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync32(from))
+  if (!existsSync33(from))
     return;
   mkdirSync8(dirname11(to), { recursive: true });
   rmSync7(to, { recursive: true, force: true });
-  renameSync5(from, to);
+  renameSync6(from, to);
 }
 
 // ../daemon/src/worktrees/archivedGit.ts
@@ -33102,95 +33476,6 @@ class ArchivedGit {
   }
 }
 
-// ../daemon/src/worktrees/counts.ts
-var COUNTS_FLOOR_MS = 1e4;
-var same2 = (a, b) => a.ahead === b.ahead && a.behind === b.behind && a.unpushed === b.unpushed && a.dirty === b.dirty;
-
-class Counts {
-  d;
-  cache = new Map;
-  reading = new Map;
-  marks = new Map;
-  markAll = 0;
-  constructor(d) {
-    this.d = d;
-  }
-  get(id) {
-    return this.cache.get(id)?.value;
-  }
-  stale(id) {
-    if (id === undefined) {
-      this.markAll++;
-      for (const c of this.cache.values())
-        c.at = 0;
-      return;
-    }
-    this.marks.set(id, (this.marks.get(id) ?? 0) + 1);
-    const c = this.cache.get(id);
-    if (c)
-      c.at = 0;
-  }
-  put(id, value) {
-    return this.store(id, value);
-  }
-  refresh(ids) {
-    const reads = [];
-    for (const id of new Set(ids)) {
-      const running = this.reading.get(id);
-      if (running) {
-        reads.push(running);
-        continue;
-      }
-      const cached = this.cache.get(id);
-      if (cached && Date.now() - cached.at < COUNTS_FLOOR_MS)
-        continue;
-      if (this.d.going(id))
-        continue;
-      reads.push(this.readOne(id));
-    }
-    if (!reads.length)
-      return null;
-    return Promise.all(reads).then((moved) => moved.some(Boolean));
-  }
-  async read(id) {
-    this.stale(id);
-    await this.refresh([id]);
-    const c = this.cache.get(id);
-    return c?.failed || !c?.value ? null : c.value;
-  }
-  markOf(id) {
-    return (this.marks.get(id) ?? 0) + this.markAll;
-  }
-  readOne(id) {
-    const read = (async () => {
-      for (;; ) {
-        const mark = this.markOf(id);
-        let value = null;
-        try {
-          value = await this.d.read(id);
-        } catch {}
-        if (this.d.going(id))
-          return false;
-        if (this.markOf(id) !== mark)
-          continue;
-        if (value)
-          return this.store(id, value);
-        this.cache.set(id, { value: this.get(id), at: Date.now(), failed: true });
-        return false;
-      }
-    })().finally(() => {
-      this.reading.delete(id);
-    });
-    this.reading.set(id, read);
-    return read;
-  }
-  store(id, value) {
-    const prev = this.cache.get(id)?.value;
-    this.cache.set(id, { value, at: Date.now() });
-    return !prev || !same2(prev, value);
-  }
-}
-
 // ../daemon/src/worktrees/landSubjects.ts
 function unfilled(mark) {
   return mark.subjects === undefined;
@@ -33209,15 +33494,19 @@ async function fillLandMarks(jobs, read, width = 8) {
 }
 
 // ../daemon/src/worktrees/spare.ts
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { basename as basename12, join as join29 } from "path";
 class SparePool {
   d;
   inflight = new Map;
   refreshing = new Map;
+  writing = new Set;
   constructor(d) {
     this.d = d;
   }
+  checkingOut(id) {
+    return this.writing.has(id);
+  }
   spareOf(repoId) {
     return this.d.state.worktrees.find((w) => w.repoId === repoId && w.kind === "spare");
   }
@@ -33229,7 +33518,7 @@ class SparePool {
     if (!text.trim())
       return;
     const wt = this.d.state.worktree(boxId);
-    if (wt?.kind !== "spare" || !existsSync33(wt.path))
+    if (wt?.kind !== "spare" || !existsSync34(wt.path))
       return;
     const agent = this.d.runtime.ensureAgent(wt).agent;
     if (agent.runningAgent === null)
@@ -33293,16 +33582,18 @@ class SparePool {
     const repoId = repo.id;
     let cut = () => {};
     const added = (async () => {
-      if (existsSync33(wt.path))
+      if (existsSync34(wt.path))
         return;
       const run = this.d.runs.begin(wt.id, "setup", {
         timeoutMs: timeoutFor(repo.config, "setup"),
         stage: "checking out"
       });
+      this.writing.add(wt.id);
       try {
         await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--detach", "--no-checkout", wt.path, baseOf(repo)));
         await withLock(`checkout:${repo.path}`, () => gitOrThrow(wt.path, "reset", "--hard"));
       } finally {
+        this.writing.delete(wt.id);
         run.finish(0);
       }
     })();
@@ -33352,7 +33643,7 @@ class SparePool {
     }
     log.warn(wt.repoId, "spare warm-up failed; rolling back", e);
     this.d.carryDraft?.(wt.id, wt.repoId);
-    if (existsSync33(wt.path)) {
+    if (existsSync34(wt.path)) {
       await this.d.discard(wt.id).catch((re) => log.warn(wt.repoId, "spare rollback failed", re));
       return;
     }
@@ -33424,7 +33715,7 @@ class SparePool {
       try {
         await running?.added;
         running?.cut();
-        if (!existsSync33(wt.path))
+        if (!existsSync34(wt.path))
           throw new Error("the worktree's directory is gone");
         await this.refreshing.get(repoId);
         await prepare(wt);
@@ -33452,7 +33743,7 @@ class SparePool {
     for (const k of Object.keys(stamps))
       delete wt[k];
     delete wt.promptedAt;
-    if (!existsSync33(wt.path)) {
+    if (!existsSync34(wt.path)) {
       await this.rollBack(wt, e);
       return;
     }
@@ -33463,6 +33754,518 @@ class SparePool {
   }
 }
 
+// ../daemon/src/worktrees/treeState.ts
+import { watch as watch2 } from "fs";
+import { stat as stat5 } from "fs/promises";
+import { join as join30 } from "path";
+var EDIT_DELAY_MS = 150;
+var SHELL_QUIET_MS2 = 1500;
+var WATCH_DELAY_MS = 300;
+var FLOOR_MS = 5 * 60000;
+var FLOOR_BATCH = 3;
+var SLOTS = { fg: 6, bg: 3, extras: 2 };
+var RETRY_MS = [2000, 1e4, 60000];
+var SIGNATURE_STATS = 2000;
+var sameCounts = (a, b) => !!a && a.ahead === b.ahead && a.behind === b.behind && a.unpushed === b.unpushed && a.dirty === b.dirty;
+
+class TreeState {
+  d;
+  records = new Map;
+  reading = new Map;
+  marks = new Map;
+  markAll = 0;
+  extrasRunning = new Map;
+  inSideEffects = new Set;
+  extrasAgain = new Set;
+  timers = new Map;
+  lastFailure = new Map;
+  retries = new Map;
+  watchers = new Map;
+  pending = new Set;
+  offs = [];
+  stopped = false;
+  slots;
+  constructor(d) {
+    this.d = d;
+    this.slots = d.slots ?? SLOTS;
+    const { hub } = d;
+    this.offs.push(hub.on("agent", (id, _seq, event) => {
+      if (event.type === "tool-end" || event.type === "turn-end")
+        this.signal(id, "edit");
+    }), hub.on("filesChanged", (id) => this.signal(id, "edit")), hub.on("termData", (id, stream) => {
+      if (stream === SHELL_STREAM)
+        this.signal(id, "shell");
+    }), hub.on("turnSettled", (id) => this.signal(id, "now")), hub.on("repoTick", (repoId) => {
+      for (const id of this.d.rowsOf(repoId)) {
+        this.invalidate(id);
+        if (this.hot(id))
+          this.signal(id, "now");
+      }
+    }));
+  }
+  now() {
+    return (this.d.now ?? Date.now)();
+  }
+  get(id) {
+    return this.records.get(id);
+  }
+  counts(id) {
+    const rec = this.records.get(id);
+    if (!rec)
+      return;
+    const { ahead, behind, unpushed } = rec.core;
+    return {
+      ...ahead === undefined ? {} : { ahead },
+      ...behind === undefined ? {} : { behind },
+      ...unpushed === undefined ? {} : { unpushed },
+      dirty: rec.core.files.length
+    };
+  }
+  frame(id) {
+    const rec = this.records.get(id);
+    if (!rec)
+      return null;
+    const { ahead, behind, unpushed, head } = rec.core;
+    const x = rec.extras;
+    const files = x ? rec.core.files.map((f) => ({ ...f, ...x.counts.get(f.path) ?? {} })) : rec.core.files;
+    return {
+      version: rec.version,
+      files,
+      ...ahead === undefined ? {} : { ahead },
+      ...behind === undefined ? {} : { behind },
+      ...unpushed === undefined ? {} : { unpushed },
+      ...head === undefined ? {} : { head },
+      ...x ? { extras: { committed: x.committed ?? [], ...x.turn ? { turn: x.turn } : {} } } : {}
+    };
+  }
+  async current(id, waitExtrasMs = 0) {
+    if (!this.records.has(id))
+      await this.refresh(id);
+    const rec = this.records.get(id);
+    if (!rec)
+      return null;
+    if (!rec.extras && this.d.interested(id)) {
+      this.scheduleExtras(id);
+      const run = this.extrasRunning.get(id);
+      if (run && waitExtrasMs > 0) {
+        await Promise.race([run, new Promise((r) => setTimeout(r, waitExtrasMs))]);
+      }
+    }
+    return this.frame(id);
+  }
+  async full(id) {
+    const rec = await this.refresh(id);
+    if (!rec)
+      return { frame: null, moved: false };
+    if (!rec.extras) {
+      this.scheduleExtras(id, true);
+      await this.extrasRunning.get(id);
+    }
+    return { frame: this.frame(id), moved: rec.moved };
+  }
+  invalidate(id) {
+    this.marks.set(id, (this.marks.get(id) ?? 0) + 1);
+    const rec = this.records.get(id);
+    if (rec)
+      rec.staleSince ??= this.now();
+  }
+  invalidateAll() {
+    this.markAll++;
+    const now = this.now();
+    for (const [id, rec] of this.records) {
+      rec.staleSince ??= now;
+      if (this.hot(id))
+        this.kick(id);
+    }
+  }
+  forget(id) {
+    this.records.delete(id);
+    this.marks.delete(id);
+    this.lastFailure.delete(id);
+    this.unwatch(id);
+    const retry = this.retries.get(id);
+    if (retry) {
+      clearTimeout(retry);
+      this.retries.delete(id);
+    }
+    const t = this.timers.get(id);
+    if (t) {
+      clearTimeout(t.t);
+      this.timers.delete(id);
+      t.done();
+    }
+  }
+  refresh(id) {
+    this.invalidate(id);
+    if (this.d.going(id))
+      return Promise.resolve(null);
+    if (this.inSideEffects.has(id)) {
+      const rec = this.records.get(id);
+      return Promise.resolve(rec ? { ...rec, moved: false } : null);
+    }
+    return this.reading.get(id) ?? this.readOne(id);
+  }
+  refreshStale(ids) {
+    const reads = [];
+    const floor = [];
+    const now = this.now();
+    for (const id of new Set(ids)) {
+      if (this.d.going(id))
+        continue;
+      const running = this.reading.get(id);
+      if (running) {
+        reads.push(running.then(() => false));
+        continue;
+      }
+      const rec = this.records.get(id);
+      if (!rec) {
+        const failed = this.lastFailure.get(id);
+        if (failed === undefined || now - failed > (this.d.floorMs ?? FLOOR_MS))
+          reads.push(this.readMoved(id));
+        continue;
+      }
+      if (rec.failedAt !== undefined && this.retries.has(id))
+        continue;
+      if (rec.staleSince !== undefined && this.hot(id)) {
+        reads.push(this.readMoved(id));
+        continue;
+      }
+      if (rec.staleSince !== undefined || now - rec.readAt > (this.d.floorMs ?? FLOOR_MS)) {
+        floor.push({ id, at: rec.staleSince ?? rec.readAt });
+      }
+    }
+    floor.sort((a, b) => a.at - b.at);
+    for (const { id } of floor.slice(0, this.d.floorBatch ?? FLOOR_BATCH))
+      reads.push(this.readMoved(id));
+    if (!reads.length)
+      return null;
+    const all = Promise.all(reads).then((moved) => moved.some(Boolean));
+    this.track(all);
+    return all;
+  }
+  signal(id, kind) {
+    if (this.stopped)
+      return;
+    const prev = this.timers.get(id);
+    const delay = kind === "now" ? 0 : kind === "edit" ? this.d.editDelayMs ?? EDIT_DELAY_MS : this.d.shellQuietMs ?? SHELL_QUIET_MS2;
+    const at = Date.now() + delay;
+    if (prev) {
+      if (kind !== "now" && prev.at <= at)
+        return;
+      clearTimeout(prev.t);
+      this.timers.delete(id);
+      prev.done();
+    }
+    if (kind === "now") {
+      this.kick(id);
+      return;
+    }
+    let done = () => {};
+    const waited = new Promise((r) => {
+      done = r;
+    });
+    this.track(waited);
+    const t = setTimeout(() => {
+      this.timers.delete(id);
+      done();
+      this.kick(id);
+    }, delay);
+    t.unref?.();
+    this.timers.set(id, { at, t, done });
+  }
+  kick(id) {
+    this.invalidate(id);
+    if (this.d.going(id))
+      return;
+    const read = this.reading.get(id) ?? this.readOne(id);
+    this.track(read.then((rec) => {
+      if (rec?.moved)
+        this.d.hub.emit("worktreesChanged");
+    }));
+  }
+  watch(id) {
+    const r = this.d.readable(id);
+    if (!r || this.watchers.has(id) || this.stopped)
+      return;
+    if (this.records.has(id))
+      this.scheduleExtras(id);
+    let timer = null;
+    const ignore = new Set([".git"]);
+    let w;
+    try {
+      w = watch2(r.path, { recursive: true }, (_event, filename) => {
+        const name = filename ? String(filename) : "";
+        if (!name)
+          return;
+        for (const dir of ignore)
+          if (name === dir || name.startsWith(`${dir}/`))
+            return;
+        if (timer)
+          clearTimeout(timer);
+        timer = setTimeout(() => {
+          timer = null;
+          this.signal(id, "edit");
+        }, this.d.watchDelayMs ?? WATCH_DELAY_MS);
+        timer.unref?.();
+      });
+    } catch (e) {
+      log.warn(id, "could not watch the worktree", e);
+      return;
+    }
+    w.on("error", (e) => {
+      log.warn(id, "the worktree watcher stopped", e);
+      this.unwatch(id);
+    });
+    w.unref?.();
+    this.watchers.set(id, { w, ignore });
+    fireAndForget(id, git(r.path, "ls-files", "-o", "-i", "--exclude-standard", "--directory").then((res) => {
+      if (!res.ok)
+        return;
+      for (const line of res.out.split(`
+`)) {
+        const dir = line.replace(/\/$/, "");
+        if (dir)
+          ignore.add(dir);
+      }
+    }), "ignored folders for the watcher");
+  }
+  unwatch(id) {
+    const w = this.watchers.get(id);
+    if (!w)
+      return;
+    this.watchers.delete(id);
+    w.w.close();
+  }
+  async settled() {
+    let waited = false;
+    while (this.pending.size) {
+      waited = true;
+      await Promise.all(this.pending);
+    }
+    return waited;
+  }
+  stop() {
+    this.stopped = true;
+    for (const off of this.offs)
+      off();
+    for (const [id, t] of this.timers) {
+      clearTimeout(t.t);
+      this.timers.delete(id);
+      t.done();
+    }
+    for (const t of this.retries.values())
+      clearTimeout(t);
+    this.retries.clear();
+    for (const id of [...this.watchers.keys()])
+      this.unwatch(id);
+  }
+  hot(id) {
+    return this.d.interested(id) || this.d.shown(id) || this.d.live(id);
+  }
+  markOf(id) {
+    return (this.marks.get(id) ?? 0) + this.markAll;
+  }
+  track(p) {
+    this.pending.add(p);
+    const done = () => this.pending.delete(p);
+    p.then(done, done);
+    return p;
+  }
+  readMoved(id) {
+    return this.readOne(id).then((rec) => !!rec?.moved);
+  }
+  readOne(id) {
+    const read = (async () => {
+      for (let reruns = 0;; ) {
+        const mark = this.markOf(id);
+        const r = this.d.readable(id);
+        if (!r) {
+          this.records.delete(id);
+          return null;
+        }
+        let core = null;
+        const key = this.hot(id) ? "tree:fg" : "tree:bg";
+        const cap = key === "tree:fg" ? this.slots.fg : this.slots.bg;
+        try {
+          core = await withSlot(key, cap, () => (this.d.readCore ?? this.readCore)(r));
+          treeReads.core++;
+        } catch (e) {
+          log.warn(id, "git state read failed", e);
+        }
+        if (this.d.going(id))
+          return null;
+        if (this.markOf(id) !== mark) {
+          treeReads.superseded++;
+          continue;
+        }
+        if (!core) {
+          this.noteFailure(id);
+          return null;
+        }
+        let again = false;
+        if (r.wt) {
+          this.inSideEffects.add(id);
+          try {
+            again = await this.d.afterCore(r, core);
+          } catch (e) {
+            log.warn(id, "git state side effects failed", e);
+          } finally {
+            this.inSideEffects.delete(id);
+          }
+        }
+        if (again && reruns++ === 0)
+          continue;
+        if (this.markOf(id) !== mark) {
+          treeReads.superseded++;
+          continue;
+        }
+        return this.store(id, core);
+      }
+    })().finally(() => this.reading.delete(id));
+    this.reading.set(id, read);
+    return read;
+  }
+  readCore = async (r) => {
+    const isMain = r.wt?.kind === "main";
+    const countable = !isMain && (!!r.wt || !!r.branch);
+    const [entries, ab, unpushed, head, branch] = await Promise.all([
+      statusEntries(r.path),
+      isMain ? this.d.trunkBehind(r.id, r.path) : countable ? aheadBehind(r.path, r.base) : Promise.resolve({}),
+      this.d.prOpen(r.id) ? aheadUpstream(r.path, r.branch) : Promise.resolve(null),
+      git(r.path, "rev-parse", "HEAD"),
+      git(r.path, "branch", "--show-current")
+    ]);
+    const files = entries.files.map((f) => ({
+      path: f.path,
+      xy: f.xy,
+      ...entries.folded.has(f.path) ? { add: f.add, del: f.del } : {}
+    }));
+    const stats = await Promise.all(files.slice(0, SIGNATURE_STATS).map((f) => stat5(join30(r.path, f.path)).then((s) => `${s.mtimeMs}:${s.size}`, () => "-")));
+    const t0 = performance.now();
+    const counts = { ...ab, ...unpushed === null ? {} : { unpushed } };
+    const signature = String(Bun.hash([
+      head.ok ? head.out : "",
+      counts.ahead,
+      counts.behind,
+      counts.unpushed,
+      ...files.map((f) => `${f.xy}${f.path}`),
+      ...stats
+    ].join("\x00")));
+    noteSync("tree.signature", performance.now() - t0);
+    return {
+      files,
+      ...counts,
+      ...head.ok ? { head: head.out } : {},
+      ...branch.ok && branch.out ? { branch: branch.out } : {},
+      folded: entries.folded,
+      signature
+    };
+  };
+  readExtras = async (r, core, folded) => {
+    const isMain = r.wt?.kind === "main";
+    const counts = await countEntries(r.path, core.files, folded);
+    const committed = !isMain && (core.ahead ?? 0) > 0 ? await committedFiles(r.path, r.base) : undefined;
+    const turn = r.wt && core.files.length > 0 ? await turnChanges(r.path, r.wt.id, r.base, !isMain, core.files) : null;
+    return { counts, ...committed ? { committed } : {}, ...turn ? { turn } : {} };
+  };
+  store(id, read) {
+    const { folded, signature, ...core } = read;
+    const prev = this.records.get(id);
+    const now = this.now();
+    const retry = this.retries.get(id);
+    if (retry) {
+      clearTimeout(retry);
+      this.retries.delete(id);
+    }
+    this.lastFailure.delete(id);
+    if (prev && prev.signature === signature) {
+      prev.readAt = now;
+      prev.staleSince = undefined;
+      prev.failedAt = undefined;
+      prev.failures = 0;
+      return { ...prev, moved: false };
+    }
+    const before = prev && this.counts(id);
+    const rec = {
+      version: (prev?.version ?? 0) + 1,
+      core,
+      signature,
+      folded,
+      readAt: now,
+      failures: 0
+    };
+    this.records.set(id, rec);
+    const moved = !sameCounts(before, this.counts(id));
+    if (this.d.interested(id)) {
+      this.d.hub.emit("treeChanged", id);
+      this.scheduleExtras(id);
+    }
+    return { ...rec, moved };
+  }
+  noteFailure(id) {
+    treeReads.failed++;
+    const now = this.now();
+    const rec = this.records.get(id);
+    this.lastFailure.set(id, now);
+    if (rec) {
+      if (rec.failedAt === undefined)
+        log.warn(id, "git could not read the tree; the last numbers stand");
+      rec.failedAt = now;
+      rec.failures++;
+      rec.readAt = now;
+      rec.staleSince = undefined;
+    }
+    if (!this.d.interested(id) || this.retries.has(id) || this.stopped)
+      return;
+    const delay = RETRY_MS[Math.min((rec?.failures ?? 1) - 1, RETRY_MS.length - 1)] ?? RETRY_MS[0];
+    const t = setTimeout(() => {
+      this.retries.delete(id);
+      if (this.d.interested(id))
+        this.kick(id);
+    }, delay);
+    t.unref?.();
+    this.retries.set(id, t);
+  }
+  scheduleExtras(id, asked = false) {
+    if (this.extrasRunning.has(id)) {
+      this.extrasAgain.add(id);
+      return;
+    }
+    const rec = this.records.get(id);
+    if (!rec || rec.extras || !(asked || this.d.interested(id)) || this.stopped)
+      return;
+    const version = rec.version;
+    const run = (async () => {
+      const r = this.d.readable(id);
+      if (!r)
+        return;
+      let extras;
+      try {
+        extras = await withSlot("tree:extras", this.slots.extras, () => (this.d.readExtras ?? this.readExtras)(r, rec.core, rec.folded));
+        treeReads.extras++;
+      } catch (e) {
+        log.warn(id, "git state extras failed", e);
+        return;
+      }
+      const now = this.records.get(id);
+      if (!now || now.version !== version || this.d.going(id)) {
+        treeReads.superseded++;
+        return;
+      }
+      now.extras = extras;
+      now.version++;
+      if (this.d.interested(id))
+        this.d.hub.emit("treeChanged", id);
+    })().finally(() => {
+      this.extrasRunning.delete(id);
+      if (this.extrasAgain.delete(id))
+        this.scheduleExtras(id);
+    });
+    this.extrasRunning.set(id, run);
+    this.track(run);
+  }
+}
+
 // ../daemon/src/worktrees/trunk.ts
 var FETCH_EVERY_MS = 5 * 60000;
 var OPEN_FETCH_MIN_MS = 60000;
@@ -33489,11 +34292,9 @@ class Trunk {
         const main = this.d.state.worktree(mainId);
         if (main)
           this.noteFetch(main.repoId, r);
-        if (!r.ok) {
-          log.warn("fetch", `could not fetch ${path}: ${r.err.slice(0, 200)}`);
+        if (!r.ok)
           return;
-        }
-        this.d.invalidateCounts();
+        this.d.invalidateCounts(mainId);
         this.d.hub.emit("worktreesChanged");
         if (await behindUpstream(path) ?? 0)
           await this.follow(mainId);
@@ -33512,11 +34313,9 @@ class Trunk {
     this.lastFetch.set(repo.path, Date.now());
     const f = await withFetchLock(repo.path, () => run(GIT, ["fetch", "--quiet"], repo.path, NO_PROMPT));
     this.noteFetch(repo.id, f);
-    if (!f.ok) {
-      log.warn("fetch", `could not fetch ${repo.path}: ${f.err.slice(0, 200)}`);
+    if (!f.ok)
       return;
-    }
-    this.d.invalidateCounts();
+    this.d.invalidateCounts(main.id);
     await this.follow(main.id);
   }
   noteFetch(repoId, r) {
@@ -33524,6 +34323,11 @@ class Trunk {
     const next = r.ok ? { at: Date.now() } : { ...was.at ? { at: was.at } : {}, failed: r.err.split(`
 `).find((l) => l.trim()) ?? "fetch failed" };
     this.fetches.set(repoId, next);
+    const path = this.d.state.repo(repoId)?.path ?? repoId;
+    if (next.failed !== undefined && next.failed !== was.failed)
+      log.warn("fetch", `could not fetch ${path}: ${next.failed}`);
+    if (r.ok && was.failed !== undefined)
+      log.info("fetch", `origin answers again for ${path}`);
     if (was.failed !== next.failed || was.at !== next.at)
       this.d.hub.emit("worktreesChanged");
   }
@@ -33538,7 +34342,7 @@ class Trunk {
     this.noteFetch(repo.id, f);
     if (!f.ok)
       return { ok: false, message: refused2("fetch failed", f) };
-    this.d.invalidateCounts();
+    this.d.invalidateCounts(main.id);
     return this.follow(main.id);
   }
   async catchUp(repoId) {
@@ -33559,7 +34363,7 @@ class Trunk {
     else
       this.stale.delete(repo.id);
     if (ff.moved) {
-      this.d.invalidateCounts();
+      this.d.invalidateCounts(mainId);
       this.d.hub.emit("worktreesChanged");
     } else if (was !== ff.stale)
       this.d.hub.emit("worktreesChanged");
@@ -33656,6 +34460,7 @@ function stopOf(prev, next) {
 }
 
 // ../daemon/src/worktrees/service.ts
+var LIST_FLOOR_MS = 1e4;
 var LOCAL_CONFIG_FILES = [".env", ".env.local", ".env.development", ".env.development.local", ".dev.vars"];
 var BASE_IGNORE = "base .gitignore";
 var REFUSAL_CHARS = 400;
@@ -33702,7 +34507,7 @@ class WorktreeService {
   going = new Set;
   arriving = new Set;
   firstPrompt = new Map;
-  counts;
+  tree;
   handChecked = new Map;
   naming = new Set;
   discoverCache = new Map;
@@ -33714,15 +34519,23 @@ class WorktreeService {
     this.d = d;
     this.runs = d.runs ?? new RunService({ state: d.state, hub: d.hub });
     this.archive = new WorktreeArchive(d.paths.archiveDir);
-    this.counts = new Counts({
-      read: (id) => this.readCounts(id),
-      going: (id) => this.going.has(id) || this.arriving.has(id)
-    });
     this.trunk = new Trunk({
       state: d.state,
       hub: d.hub,
-      counts: (main) => this.counts.get(main.id),
-      invalidateCounts: () => this.counts.stale()
+      counts: (main) => this.tree.counts(main.id),
+      invalidateCounts: (mainId) => this.tree.invalidate(mainId)
+    });
+    this.tree = new TreeState({
+      hub: d.hub,
+      readable: (id) => this.readable(id),
+      going: (id) => this.going.has(id) || this.arriving.has(id) || this.spare.checkingOut(id),
+      interested: (id) => d.interested?.(id) ?? false,
+      shown: (id) => d.shown?.(id) ?? false,
+      live: (id) => d.runtime.busy(id),
+      trunkBehind: (mainId, path) => this.trunk.behind(mainId, path),
+      prOpen: (id) => d.state.worktree(id)?.pr?.state === "open",
+      afterCore: (r, core) => this.afterCore(r, core),
+      rowsOf: (repoId) => this.rowsOf(repoId)
     });
     this.spare = new SparePool({
       state: d.state,
@@ -33762,7 +34575,6 @@ class WorktreeService {
       this.usage.set(worktreeId, { used, size, ...cost !== undefined ? { cost } : {} });
     });
     d.hub.on("turnSettled", (worktreeId, turn) => {
-      this.counts.stale(worktreeId);
       if (turn.end === "done") {
         const wt = d.state.worktree(worktreeId);
         const prompt = wt?.unnamed ? firstAskOf(d.runtime.agentFor(worktreeId)?.transcript() ?? []) : undefined;
@@ -33854,8 +34666,8 @@ class WorktreeService {
     if (!await isGitRepo(repo.path)) {
       throw new UserError(`git no longer reads ${repo.name} as a checkout, so there is nothing to start a worktree from. If \`git config core.bare\` says true there, \`git config --unset core.bare\` puts it back.`);
     }
-    const { id, dir } = freeSlot(join30(this.d.paths.worktreesDir, repo.name));
-    const wtPath = join30(this.d.paths.worktreesDir, repo.name, dir);
+    const { id, dir } = freeSlot(join31(this.d.paths.worktreesDir, repo.name));
+    const wtPath = join31(this.d.paths.worktreesDir, repo.name, dir);
     const branch = `toyon/${dir}`;
     await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--no-track", "-b", branch, wtPath, baseOf(repo)));
     const wt = {
@@ -33905,14 +34717,12 @@ class WorktreeService {
   async carryMainOrThrow(repo, wt, move) {
     const main = repo.defaultBranch;
     if (!move) {
-      const count = this.counts.get(this.mainOf(repo.id)?.id ?? "")?.dirty ?? 0;
+      const count = this.tree.counts(this.mainOf(repo.id)?.id ?? "")?.dirty ?? 0;
       return { branch: main, moved: false, count };
     }
     let count = 0;
-    let left;
     const unmoved = await withRepoLock(repo.path, async () => {
       count = (await statusFiles(repo.path)).length;
-      left = count;
       if (count === 0)
         return;
       const before = await git(repo.path, "rev-parse", "-q", "--verify", "refs/stash");
@@ -33923,7 +34733,6 @@ class WorktreeService {
       const sha = after.out.trim();
       if (!after.ok || before.ok && before.out.trim() === sha)
         return;
-      left = 0;
       const entry = async () => {
         const list = await git(repo.path, "stash", "list", "--format=%H");
         const i = list.out.split(`
@@ -33932,7 +34741,7 @@ class WorktreeService {
       };
       const carried = await git(repo.path, "ls-tree", "-r", "--name-only", `${sha}^3`);
       const restored = (carried.ok ? carried.out.split(`
-`).filter(Boolean) : []).filter((p) => !existsSync34(join30(wt.path, p)));
+`).filter(Boolean) : []).filter((p) => !existsSync35(join31(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -33947,14 +34756,11 @@ class WorktreeService {
       }
       const ref = await entry();
       const back = ref ? await git(repo.path, "stash", "pop", ref) : null;
-      left = back?.ok ? count : undefined;
       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.mainOf(repo.id);
     if (mainWt) {
-      if (left !== undefined)
-        this.counts.put(mainWt.id, { ...this.counts.get(mainWt.id), dirty: left });
-      this.counts.stale(mainWt.id);
+      await this.tree.refresh(mainWt.id);
     }
     return { branch: main, moved: count > 0 && !unmoved, count, unmoved };
   }
@@ -33972,9 +34778,9 @@ class WorktreeService {
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
     let slug = branchSlug(title) || "branch";
-    if (existsSync34(join30(this.d.paths.worktreesDir, repo.name, slug)))
+    if (existsSync35(join31(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
-    const wtPath = join30(this.d.paths.worktreesDir, repo.name, slug);
+    const wtPath = join31(this.d.paths.worktreesDir, repo.name, slug);
     await withRepoLock(repo.path, async () => {
       const out = (await listWorktrees(repo.path)).find((w) => w.branch === branch);
       if (out)
@@ -34223,6 +35029,7 @@ class WorktreeService {
     const sessionId = this.d.state.session(worktreeId);
     const placed = repo.promptedAt;
     this.d.state.removeWorktree(worktreeId);
+    this.tree.forget(worktreeId);
     if (repo.promptedAt !== placed)
       this.d.hub.emit("reposChanged");
     releasePort(wt.proxyPort);
@@ -34240,7 +35047,7 @@ class WorktreeService {
   }
   async teardown(wt, repo) {
     const cmds = repo.config.teardown ?? [];
-    if (cmds.length === 0 || !existsSync34(wt.path))
+    if (cmds.length === 0 || !existsSync35(wt.path))
       return;
     for (const cmd of cmds) {
       const code = await runSetup(cmd, wt.path, (line) => this.d.hub.emit("log", wt.id, "setup", line), worktreeEnv(wt, repo), { timeoutMs: timeoutFor(repo.config, "setup") });
@@ -34249,7 +35056,7 @@ class WorktreeService {
     }
   }
   async keep(repo, wt) {
-    const index = join30(this.d.paths.archiveDir, `${wt.id}.index`);
+    const index = join31(this.d.paths.archiveDir, `${wt.id}.index`);
     const kept = await keepState(repo.path, wt.path, archiveRef(wt.id), index) ?? await this.keepUnlinked(repo, wt);
     if (!kept)
       log.warn(wt.id, "could not keep its git state");
@@ -34286,11 +35093,11 @@ class WorktreeService {
       log.warn(wt.id, `its directory could not be deleted and stays at ${wt.path}`);
   }
   plansScratch(worktreeId) {
-    return join30(this.d.paths.archiveDir, `${worktreeId}.plans`);
+    return join31(this.d.paths.archiveDir, `${worktreeId}.plans`);
   }
   keepPlans(wt) {
-    const from = join30(wt.path, PLANS_DIR);
-    if (!existsSync34(from))
+    const from = join31(wt.path, PLANS_DIR);
+    if (!existsSync35(from))
       return;
     try {
       cpSync(from, this.plansScratch(wt.id), { recursive: true });
@@ -34341,6 +35148,7 @@ class WorktreeService {
     const repo = this.d.state.repo(wt.repoId);
     const sessionId = this.d.state.session(wt.id);
     this.d.state.removeWorktree(wt.id);
+    this.tree.forget(wt.id);
     if (!repo || wt.kind !== "worktree") {
       this.deleteChat(wt.id);
       return;
@@ -34429,7 +35237,7 @@ class WorktreeService {
   }
   archivedAttachment(archiveId, file) {
     const files = this.archive.chatFiles(archiveId);
-    return files && isAttachmentFile(file) ? join30(files.attachments, file) : null;
+    return files && isAttachmentFile(file) ? join31(files.attachments, file) : null;
   }
   archivedGit(archiveId) {
     const rec = this.archive.get(archiveId);
@@ -34443,7 +35251,8 @@ class WorktreeService {
     if (!kept)
       return null;
     try {
-      return await kept.status();
+      const { files, committed, head } = await kept.status();
+      return { version: 0, files, head, extras: { committed } };
     } catch (e) {
       log.warn(archiveId, "reading its kept changes failed", e);
       return null;
@@ -34484,7 +35293,7 @@ class WorktreeService {
       throw new UserError(`${old.title} was archived without its commits, so there is nothing to restore`);
     if (rec.auto)
       log.info(old.id, `restoring a worktree that archived itself (${rec.auto})`);
-    const path = existsSync34(old.path) ? join30(dirname12(old.path), freeSlot(dirname12(old.path)).dir) : old.path;
+    const path = existsSync35(old.path) ? join31(dirname12(old.path), freeSlot(dirname12(old.path)).dir) : old.path;
     const { variant: _variant, ...rest } = old;
     const wt = {
       ...rest,
@@ -34523,11 +35332,11 @@ class WorktreeService {
     run.finish(0);
     this.arriving.delete(wt.id);
     wt.branch = branch;
-    move(chat.plans, join30(path, PLANS_DIR));
+    move(chat.plans, join31(path, PLANS_DIR));
     const dropped = await git(repo.path, "update-ref", "-d", archiveRef(old.id));
     if (!dropped.ok)
       log.warn(old.id, `could not drop its archive ref: ${dropped.err}`);
-    this.counts.stale(wt.id);
+    this.tree.invalidate(wt.id);
     this.d.state.save();
     this.d.hub.emit("worktreesChanged");
     fireAndForget(wt.id, this.setupAndStart(wt, repo, repo.path), "setup + start");
@@ -34590,6 +35399,7 @@ class WorktreeService {
       agent.unqueue(0);
     await this.d.runtime.stop(wt.id);
     this.d.state.removeWorktree(wt.id, { refused: true });
+    this.tree.forget(wt.id);
     releasePort(wt.proxyPort);
   }
   async deleteArchived(archiveId) {
@@ -34598,12 +35408,12 @@ class WorktreeService {
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync34(repoPath)) {
+    if (rec.kept && existsSync35(repoPath)) {
       const r = await git(repoPath, "update-ref", "-d", archiveRef(archiveId));
       if (!r.ok)
         log.warn(archiveId, `could not drop its archive ref: ${r.err}`);
     }
-    if (rec.worktree.lands?.length && existsSync34(repoPath))
+    if (rec.worktree.lands?.length && existsSync35(repoPath))
       await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
     this.d.drafts?.drop(archiveId);
@@ -34711,9 +35521,9 @@ class WorktreeService {
     }
   }
   async mirrorBaseIgnore(repo) {
-    const src = join30(repo.path, ".gitignore");
-    const tracked = existsSync34(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
-    const mirror = existsSync34(src) && !tracked;
+    const src = join31(repo.path, ".gitignore");
+    const tracked = existsSync35(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
+    const mirror = existsSync35(src) && !tracked;
     const lines = mirror ? readFileSync20(src, "utf8").split(`
 `).filter((l) => l.trim() !== "") : [];
     await excludeBlock(repo.path, BASE_IGNORE, lines);
@@ -34726,9 +35536,9 @@ class WorktreeService {
       await this.d.cache.restore(wt, repo, (line) => this.d.hub.emit("log", wt.id, "setup", line));
       run.finish(0);
     }
-    const srcNm = join30(depsSource, "node_modules");
-    const dstNm = join30(wt.path, "node_modules");
-    if (existsSync34(srcNm) && !existsSync34(dstNm)) {
+    const srcNm = join31(depsSource, "node_modules");
+    const dstNm = join31(wt.path, "node_modules");
+    if (existsSync35(srcNm) && !existsSync35(dstNm)) {
       const run = this.runs.begin(wt.id, "setup", { timeoutMs: ceiling, stage: "copying dependencies" });
       const r = await cloneTree(srcNm, dstNm);
       run.finish(0);
@@ -34738,10 +35548,10 @@ class WorktreeService {
         log.warn(wt.id, "could not copy node_modules from the base checkout", r.error);
     }
     for (const f of LOCAL_CONFIG_FILES) {
-      const src = join30(depsSource, f);
-      if (!existsSync34(src) || existsSync34(join30(wt.path, f)))
+      const src = join31(depsSource, f);
+      if (!existsSync35(src) || existsSync35(join31(wt.path, f)))
         continue;
-      const r = await run("cp", [src, join30(wt.path, f)], wt.path);
+      const r = await run("cp", [src, join31(wt.path, f)], wt.path);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `copied ${f}`);
       else
@@ -34818,6 +35628,9 @@ class WorktreeService {
     this.d.state.save();
     this.d.hub.emit("worktreesChanged");
   }
+  fingerprint(path) {
+    return (this.d.fingerprint ?? treeFingerprint)(path);
+  }
   setLanding(worktreeId, landing) {
     const wt = this.d.state.worktree(worktreeId);
     if (!wt || wt.landing === undefined && landing === undefined)
@@ -34898,7 +35711,7 @@ ${wt.landing.body}` : s;
       return;
     const { subject, body, unanswered, ...kept } = l;
     const message = opts.dropMessage ? {} : { ...subject ? { subject } : {}, ...body ? { body } : {}, ...unanswered ? { unanswered } : {} };
-    this.setLanding(wt.id, { ...kept, ...message, fingerprint: await treeFingerprint(wt.path) });
+    this.setLanding(wt.id, { ...kept, ...message, fingerprint: await this.fingerprint(wt.path) });
   }
   async landedByHand(wt, mark) {
     const repo = this.d.state.requireRepo(wt.repoId);
@@ -34931,7 +35744,13 @@ ${wt.landing.body}` : s;
       return { ...result, message: "the commit-msg hook refused the message: another is being written" };
     }
     const { hook } = result;
-    const failure = hook ? { kind: "hook", hook: hook.name, toolId: hook.toolId, command: hook.command, text: hook.text } : result.conflict ? { kind: "conflict", base, how: result.conflict, ...result.step ? { step: result.step } : {} } : null;
+    const failure = hook ? { kind: "hook", hook: hook.name, toolId: hook.toolId, command: hook.command, text: hook.text } : result.conflict ? {
+      kind: "conflict",
+      base,
+      how: result.conflict,
+      ...result.step ? { step: result.step } : {},
+      ...result.carried ? { carried: result.carried } : {}
+    } : null;
     return failure && this.d.fix.report(wt.id, failure) ? { ...result, asked: true } : result;
   }
   async fixPreview(worktreeId, clientId) {
@@ -34956,7 +35775,7 @@ ${wt.landing.body}` : s;
     if (status !== "working" && status !== "waiting")
       return null;
     const l = wt.landing;
-    if (!l || l.fingerprint === await treeFingerprint(wt.path))
+    if (!l || l.fingerprint === await this.fingerprint(wt.path))
       return null;
     return { ok: false, message: "the agent has changed files since the check: land once its turn ends" };
   }
@@ -34988,9 +35807,17 @@ ${wt.landing.body}` : s;
     const release = this.d.runtime.agentFor(id)?.hold();
     this.ops.set(id, { op });
     this.d.hub.emit("worktreesChanged");
+    const started = Date.now();
+    const watchdog = setInterval(() => {
+      const step = this.ops.get(id)?.step;
+      const at = step ? ` at "${step}"` : "";
+      log.warn(id, `${shipNoun(op)} still running after ${describeDuration(Date.now() - started)}${at}`);
+    }, RUN_CEILING_MS);
+    watchdog.unref?.();
     try {
       return await run();
     } finally {
+      clearInterval(watchdog);
       this.ops.delete(id);
       release?.();
       this.d.hub.emit("worktreesChanged");
@@ -35031,10 +35858,12 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
         const committed = await this.commitIfDirty(wt, message);
         if (committed && !committed.ok)
           return { result: committed };
+        this.tree.invalidate(wt.id);
         const taken = await takeMainIn(wt.path, base, own, w);
         if (!taken.ok)
           return { result: taken };
         await this.headMoved(wt.id);
+        this.tree.invalidate(wt.id);
         const pushed = await pushBranch(wt.path, wt.branch, w);
         if (!pushed.ok)
           return { result: pushed };
@@ -35047,6 +35876,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
       if (committed && !committed.ok)
         return { result: committed };
       const mark = await landingMark(wt.path, base);
+      this.tree.invalidate(wt.id);
       const taken = await takeMainIn(wt.path, base, own, w);
       if (!taken.ok)
         return { result: taken };
@@ -35135,6 +35965,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
       const fetched = await this.fetchBase(wt, repo, w);
       if (!fetched.ok)
         return { result: fetched };
+      this.tree.invalidate(wt.id);
       const taken = await takeMainIn(wt.path, base, own, w);
       if (!taken.ok)
         return { result: taken };
@@ -35145,6 +35976,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
         break;
       }
       squash = method === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : "";
+      this.tree.invalidate(wt.id);
       const built = await landingCommit(wt.path, wt.branch, base, method, squash, own, w);
       await this.headMoved(wt.id);
       if (!built.ok || !built.sha)
@@ -35211,11 +36043,11 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
   async restartFromMain(wt, base) {
     if (!hasOwnBranch(wt))
       return;
+    this.tree.invalidate(wt.id);
     const r = await git(wt.path, "reset", "--keep", base);
     if (!r.ok)
       log.warn(wt.id, `could not restart ${wt.branch} from ${base}: ${r.err}`);
-    this.counts.stale(wt.id);
-    await this.counts.refresh([wt.id]);
+    await this.tree.refresh(wt.id);
   }
   async fetchBase(wt, repo, w) {
     if (!baseIsRemote(repo))
@@ -35225,13 +36057,22 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
     return r;
   }
   async prMerged(worktreeId) {
-    const out = this.ops.get(worktreeId);
-    if (out)
-      return { ok: false, message: `${shipNoun(out.op)} is already running here` };
     const wt = this.d.state.worktree(worktreeId);
+    const pr = wt?.pr ? `PR #${wt.pr.number}` : "the PR";
+    const out = this.ops.get(worktreeId);
+    if (out) {
+      const message = `${shipNoun(out.op)} is already running here`;
+      log.info(worktreeId, `${pr} merged on GitHub; ${message}, landing waits`);
+      return { ok: false, message };
+    }
     if (wt && prTaken(wt))
-      return { ok: true, message: `PR #${wt.pr?.number} merged; landed already` };
+      return { ok: true, message: `${pr} merged; landed already` };
+    log.info(worktreeId, `${pr} merged on GitHub; landing it`);
     const { mark, ...result } = await this.ship(worktreeId, "land", () => this.prMergedOp(worktreeId));
+    if (result.ok)
+      log.info(worktreeId, `landed: ${result.message}`);
+    else
+      log.warn(worktreeId, `landing failed: ${result.message}`);
     if (result.ok && wt)
       this.noteLanded(wt, result.message, this.siblingIds(wt), mark);
     return result;
@@ -35284,6 +36125,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
         if (!fetched.ok)
           return fetched;
       }
+      this.tree.invalidate(worktreeId);
       const taken = await withRepoLock(repo.path, () => takeMainIn(r.path, r.base, own, w, carry));
       if (taken.ok) {
         await this.headMoved(worktreeId);
@@ -35368,19 +36210,26 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
     return found ?? undefined;
   }
   async headMoved(worktreeId) {
-    this.counts.stale(worktreeId);
-    await this.counts.refresh([worktreeId]);
+    await this.tree.refresh(worktreeId);
     this.d.hub.emit("worktreesChanged");
   }
   async recountAll() {
-    this.counts.stale();
-    await this.counts.refresh(this.countedIds());
+    this.tree.invalidateAll();
+    for (;; ) {
+      const reading = this.tree.refreshStale(this.countedIds());
+      if (!reading)
+        return;
+      await reading;
+    }
   }
   invalidateCounts(worktreeId) {
-    this.counts.stale(worktreeId);
+    if (worktreeId)
+      this.tree.invalidate(worktreeId);
+    else
+      this.tree.invalidateAll();
   }
   recount(repoId) {
-    this.counts.stale();
+    this.tree.invalidateAll();
     this.d.hub.emit("repoTick", repoId);
     const repo = this.d.state.repo(repoId);
     if (repo && baseIsRemote(repo))
@@ -35410,7 +36259,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
   }
   listDue(repoId) {
     const cached = this.discoverCache.get(repoId);
-    return !cached || Date.now() - cached.at >= COUNTS_FLOOR_MS;
+    return !cached || Date.now() - cached.at >= LIST_FLOOR_MS;
   }
   async relist(repos) {
     const moved = await Promise.all(repos.map((repo) => {
@@ -35444,29 +36293,13 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
       this.d.hub.emit("worktreesChanged");
     return any;
   }
-  async readCounts(id) {
-    const wt = this.d.state.worktree(id);
-    const found = wt ? null : this.discoveredById(id);
-    const row = wt ?? found;
-    const repo = row && this.d.state.repo(row.repoId);
-    if (!row || !repo)
-      return null;
-    const countable = wt ? !isMain(wt) : !!found?.branch;
-    const ab = countable ? await aheadBehind(row.path, baseOf(repo)) : await this.trunk.behind(id, row.path);
-    const dirty = (await statusFiles(row.path)).length;
-    const unpushed = await this.unpushed(id, row.path);
-    return { ...ab, ...unpushed === undefined ? {} : { unpushed }, dirty };
-  }
-  async unpushed(id, path) {
-    const wt = this.d.state.worktree(id);
-    if (wt?.pr?.state !== "open")
-      return;
-    return await aheadUpstream(path, wt.branch) ?? undefined;
-  }
   async freshCounts(worktreeId) {
     if (this.going.has(worktreeId))
       return {};
-    return await this.counts.read(worktreeId) ?? {};
+    const rec = await this.tree.refresh(worktreeId);
+    if (!rec || rec.failedAt !== undefined)
+      return {};
+    return { ...rec.core.ahead === undefined ? {} : { ahead: rec.core.ahead }, dirty: rec.core.files.length };
   }
   readable(id) {
     const wt = this.d.state.worktree(id);
@@ -35503,68 +36336,60 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
     if (wt && !this.going.has(worktreeId))
       await markTurn(wt.path, wt.id);
   }
-  async gitStatus(worktreeId) {
-    if (this.going.has(worktreeId) || this.arriving.has(worktreeId))
-      return null;
-    const r = this.readable(worktreeId);
-    if (!r)
-      return this.archivedStatus(worktreeId);
-    try {
-      const isMain = r.wt?.kind === "main";
-      const [files, ab, unpushed, head, current] = await Promise.all([
-        statusFilesWithCounts(r.path),
-        isMain ? Promise.resolve({}) : aheadBehind(r.path, r.base),
-        this.unpushed(worktreeId, r.path),
-        git(r.path, "rev-parse", "HEAD"),
-        git(r.path, "branch", "--show-current")
-      ]);
-      if (r.wt && current.ok)
-        await this.followBranch(r.wt, current.out);
-      const counts = { ...ab, ...unpushed === undefined ? {} : { unpushed } };
-      const ahead = counts.ahead ?? 0;
-      const committed = !isMain && ahead > 0 ? await committedFiles(r.path, r.base) : undefined;
-      const turn = r.wt && files.length > 0 ? await turnChanges(r.path, r.wt.id, r.base, !isMain, files) : null;
-      if (r.wt && !isMain && hasOwnBranch(r.wt) && files.length === 0 && ahead === 0 && head.ok && this.handChecked.get(r.wt.id) !== head.out) {
-        this.handChecked.set(r.wt.id, head.out);
-        const mark = await handLanding(r.path, r.wt.branch, r.base, r.wt.lands?.at(-1)?.tip);
-        if (mark) {
-          await this.landedByHand(r.wt, mark);
-          return this.gitStatus(worktreeId);
-        }
+  async afterCore(r, core) {
+    const wt = r.wt;
+    if (!wt)
+      return false;
+    if (this.ops.has(wt.id))
+      return false;
+    const isMain = wt.kind === "main";
+    if (core.branch)
+      await this.followBranch(wt, core.branch);
+    const { files, head } = core;
+    const ahead = core.ahead ?? 0;
+    if (!isMain && hasOwnBranch(wt) && files.length === 0 && ahead === 0 && head && this.handChecked.get(wt.id) !== head) {
+      this.handChecked.set(wt.id, head);
+      const mark = await handLanding(r.path, wt.branch, r.base, wt.lands?.at(-1)?.tip);
+      if (mark) {
+        await this.landedByHand(wt, mark);
+        return true;
       }
-      if (r.wt && !isMain && head.ok) {
-        const facts = { clean: files.length === 0, head: head.out, ahead };
-        if (prTaken(r.wt) && movedPastLand(r.wt, facts))
-          this.setPr(r.wt.id, undefined);
-        await this.refreshLanded(r.wt, facts);
-      }
-      if (r.wt?.landing && r.wt.landing.check !== "pending") {
-        const moved = r.wt.landing.fingerprint !== await treeFingerprint(r.path);
-        if (moved !== !!r.wt.landing.stale) {
-          const { stale: _was, ...rest } = r.wt.landing;
-          this.setLanding(r.wt.id, moved ? { ...rest, stale: true } : rest);
-        }
+    }
+    if (!isMain && head) {
+      const facts = { clean: files.length === 0, head, ahead };
+      if (prTaken(wt) && movedPastLand(wt, facts))
+        this.setPr(wt.id, undefined);
+      await this.refreshLanded(wt, facts);
+    }
+    const landing = wt.landing;
+    if (landing && landing.check !== "pending") {
+      const moved = landing.fingerprint !== await this.fingerprint(r.path);
+      if (wt.landing === landing && moved !== !!landing.stale) {
+        const { stale: _was, ...rest } = landing;
+        this.setLanding(wt.id, moved ? { ...rest, stale: true } : rest);
       }
-      if (r.wt && isMain)
-        this.setEmpty(r.wt, files.length === 0 ? await treeEmpty(r.path) : false);
-      if (this.going.has(worktreeId) || this.arriving.has(worktreeId))
-        return null;
-      this.noteCounts(worktreeId, isMain, files.length, counts);
-      return { files, committed, ...turn ? { turn } : {}, head: head.ok ? head.out : undefined, ...counts };
-    } catch (e) {
-      log.warn(worktreeId, "git status failed", e);
-      return null;
     }
+    if (isMain)
+      this.setEmpty(wt, files.length === 0 ? await treeEmpty(r.path) : false);
+    return false;
   }
-  noteCounts(id, main, dirty, ab) {
-    const prev = this.counts.get(id);
-    if (main && !prev)
-      return;
-    const ahead = main ? prev?.ahead : ab.ahead;
-    const behind = main ? prev?.behind : ab.behind;
-    const unpushed = main ? prev?.unpushed : ab.unpushed;
-    if (this.counts.put(id, { ahead, behind, unpushed, dirty }))
+  async gitStatus(worktreeId) {
+    if (!this.readable(worktreeId))
+      return this.archivedStatus(worktreeId);
+    const { frame, moved } = await this.tree.full(worktreeId);
+    if (moved)
       this.d.hub.emit("worktreesChanged");
+    return frame;
+  }
+  rowsOf(repoId) {
+    const ids = this.d.state.worktrees.filter((wt) => wt.repoId === repoId && this.isRow(wt)).map((wt) => wt.id);
+    for (const f of this.foundCached())
+      if (f.repoId === repoId)
+        ids.push(f.id);
+    const main = this.mainOf(repoId);
+    if (main && !ids.includes(main.id))
+      ids.push(main.id);
+    return ids;
   }
   async gitLog(worktreeId) {
     const r = this.readable(worktreeId);
@@ -35611,9 +36436,9 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
   snapshot() {
     const rows = [...this.ownedRows(), ...this.foundRows()];
     const trunks = this.trunksNow();
-    const reading = this.counts.refresh(idsOf(rows, trunks));
+    const reading = this.tree.refreshStale(idsOf(rows, trunks));
     if (reading) {
-      this.behind("counts", reading.then((moved) => {
+      this.behind("tree", reading.then((moved) => {
         if (moved)
           this.d.hub.emit("worktreesChanged");
       }), "badge counts");
@@ -35637,11 +36462,18 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
   }
   async settled() {
     let waited = false;
-    while (this.pending.size) {
-      waited = true;
-      await Promise.all(this.pending);
+    for (;; ) {
+      if (this.pending.size) {
+        waited = true;
+        await Promise.all(this.pending);
+        continue;
+      }
+      if (await this.tree.settled()) {
+        waited = true;
+        continue;
+      }
+      return waited;
     }
-    return waited;
   }
   mainOf(repoId) {
     return mainOf(this.d.state, repoId);
@@ -35658,7 +36490,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
   ownedRows() {
     return this.d.state.worktrees.filter((wt) => this.isRow(wt)).map((wt) => {
       const rt = this.d.runtime.get(wt.id);
-      const { ahead, behind, unpushed, dirty } = this.counts.get(wt.id) ?? {};
+      const { ahead, behind, unpushed, dirty } = this.tree.counts(wt.id) ?? {};
       return {
         id: wt.id,
         repoId: wt.repoId,
@@ -35686,7 +36518,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
   }
   foundRows() {
     return this.foundNow().map((f) => {
-      const { ahead, behind, dirty } = this.counts.get(f.id) ?? {};
+      const { ahead, behind, dirty } = this.tree.counts(f.id) ?? {};
       return {
         ...f,
         procs: [],
@@ -35792,6 +36624,7 @@ class ArchiveSweep {
 // ../daemon/src/index.ts
 process.on("unhandledRejection", (e) => log.error("daemon", "unhandled rejection", e));
 process.on("uncaughtException", (e) => log.error("daemon", "uncaught exception", e));
+log.info("daemon", `toyon ${package_default.version} on bun ${Bun.version}, pid ${process.pid}, ${process.argv[1]}`);
 var here = dirname13(fileURLToPath(import.meta.url));
 var {
   shellDist: SHELL_DIST,
@@ -35808,17 +36641,17 @@ if (pruned > 0)
 var managed = await loadManaged();
 var paths = makePaths();
 ensureDirs(paths);
-forwardTranscripts([paths.transcriptsDir, paths.archiveDir], join31(paths.home, "transcripts-forwarded"));
+forwardTranscripts([paths.transcriptsDir, paths.archiveDir], join32(paths.home, "transcripts-forwarded"));
 var token = loadOrCreateToken(paths);
 var port = Number(process.env.TOYON_PORT ?? DAEMON_DEFAULT_PORT);
-var helperApp = join31(paths.home, DAEMON_FILES.helper);
+var helperApp = join32(paths.home, DAEMON_FILES.helper);
 var helper = helperWanted({ platform: process.platform, cloud: cloud.enabled, port, home: process.env.TOYON_HOME }) ? new Helper({
   dir: helperApp,
   stub: HELPER_STUB,
   bun: process.execPath,
   cli: CLI_ENTRY,
-  log: join31(paths.home, DAEMON_FILES.launcherLog),
-  icon: join31(SHELL_DIST, "icon.svg"),
+  log: join32(paths.home, DAEMON_FILES.launcherLog),
+  icon: join32(SHELL_DIST, "icon.svg"),
   version: package_default.version
 }) : null;
 if (helper) {
@@ -35903,6 +36736,7 @@ var runs = new RunService({ state, hub });
 var exec = new ExecService({ state, runtime, shipping: (id) => worktrees.shippingOf(id) });
 var cache = new ArtifactCache({ paths, state, hub });
 var fix = new FixService({ state, hub, runtime });
+var interest = new Interest;
 var worktrees = new WorktreeService({
   state,
   hub,
@@ -35914,8 +36748,12 @@ var worktrees = new WorktreeService({
   watch: (id, command, run) => exec.watch(id, command, run),
   runs,
   fix,
-  pageErrors: (id) => pageErrors.ambient(id)
+  pageErrors: (id) => pageErrors.ambient(id),
+  interested: (id) => interest.isSubscribed(id),
+  shown: (id) => idle.isShown(id)
 });
+interest.onFirst((id) => worktrees.tree.watch(id));
+interest.onLast((id) => worktrees.tree.unwatch(id));
 new BackendShare({ state, hub, runtime, own: (id, names) => worktrees.ownProcs(id, names) });
 var handoff2 = new HandoffService({
   state,
@@ -36064,6 +36902,7 @@ var {
     hub,
     repos,
     worktrees,
+    interest,
     turns,
     files,
     opens,
@@ -36109,6 +36948,14 @@ fireAndForget("remote", tailnet.start(), "ask Tailscale");
 writeFileSync13(paths.pidFile, `${process.pid}
 `);
 var stopLagSampler = startLagSampler();
+fireAndForget("daemon", run("sh", ["-c", "ulimit -n"], homedir15()).then((r) => {
+  const n = Number.parseInt(r.out, 10);
+  if (!r.ok || !Number.isFinite(n))
+    return;
+  limits.fdLimit = n;
+  if (n < FD_LIMIT_LOW)
+    log.warn("daemon", fdLimitLine(n));
+}), "open-file limit");
 await runtime.reclaimOrphans();
 await repos.boot();
 drafts.prune((id) => !!state.worktree(id) || worktrees.hasArchived(id));
@@ -36131,7 +36978,7 @@ if (repoArg) {
   if (r?.front === "edge") {
     console.log(`Toyon daemon on https://${r.host}/, ${previewsLine(r)}; token read from ${paths.tokenFile}`);
   } else {
-    console.log(`Toyon daemon on http://toyon.localhost${branded ? "" : `:${port}`}/#token=${token}`);
+    console.log(`Toyon daemon on http://toyon.localhost${branded ? "" : `:${port}`}/; token read from ${paths.tokenFile}`);
     if (r)
       console.log(`         remote: https://${r.host}/, ${previewsLine(r)}`);
   }
@@ -36157,6 +37004,7 @@ async function shutdown(signal, opts = {}) {
   repos.stopWatchers();
   prs.stop();
   sweep.stop();
+  worktrees.tree.stop();
   stopLagSampler();
   stopServer();
   routes.flush();