toyon 0.14.0 → 0.16.0

package/dist/daemon.js

@@ -11,14 +11,10 @@ var TOOL_SEARCH = "ToolSearch";
 var ASK_TOOL = "AskUserQuestion";
 var TOYON_MCP_SERVER = "toyon";
 var HANDOFF_TOOL = "handoff";
-var PREVIEW_TOOL = "preview";
 
 // ../shared/src/agent-tools.ts
 var EDIT_KINDS = new Set(["edit", "delete", "move", "execute"]);
 var EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit", "Bash"]);
-function isEditTool(ev) {
-  return ev.kind ? EDIT_KINDS.has(ev.kind) : EDIT_TOOLS.has(ev.name);
-}
 var WRITE_KINDS = new Set(["edit", "delete", "move"]);
 var WRITE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 function isWriteTool(ev) {
@@ -29,7 +25,7 @@ function isWrittenKind(kind) {
   return WRITTEN_KINDS.includes(kind ?? "");
 }
 function writingCall(call, input) {
-  return (isWrittenKind(call.kind) || call.name === ASK_TOOL) && emptyInput(input);
+  return (isWrittenKind(call.kind) || call.name === ASK_TOOL || call.name === TOOL_SEARCH) && emptyInput(input);
 }
 function emptyInput(input) {
   if (!input || typeof input !== "object")
@@ -6602,11 +6598,9 @@ ${text.slice(text.length - (CONTEXT_CHARS - HEAD_CHARS))}`;
 }
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 107;
+var PROTOCOL_VERSION = 112;
 var PAGE_ERROR_MAX_CHARS = 2000;
 var PAGE_TITLE_MAX_CHARS = 1000;
-var RENDER_ERRORS_MAX = 10;
-var PAGE_URL_MAX_CHARS = 2048;
 var FILE_MAX_CHARS = 5000000;
 var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var IMAGE_MAX_EDGE = 2576;
@@ -6961,6 +6955,8 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("fix"), worktreeId: id, toolId: string2().min(1).max(200) }),
   object({ t: literal("continue"), worktreeId: id }),
   object({ t: literal("reveal"), worktreeId: id, path: relPath.optional() }),
+  object({ t: literal("reveal-path"), path: relPath }),
+  object({ t: literal("reveal-attachment"), worktreeId: id, file: string2().min(1).max(120) }),
   object({ t: literal("stop-agent"), worktreeId: id }),
   object({ t: literal("seen"), worktreeId: id }),
   object({ t: literal("mark-unread"), worktreeId: id }),
@@ -6977,17 +6973,6 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("forget-visit"), repoId: id, path: routePath }),
   object({ t: literal("page-error"), worktreeId: id, message: string2().min(1).max(PAGE_ERROR_MAX_CHARS) }),
   object({ t: literal("page-loaded"), worktreeId: id }),
-  object({ t: literal("fix-page"), worktreeId: id }),
-  object({
-    t: literal("rendered"),
-    worktreeId: id,
-    id: string2().min(1).max(64),
-    ok: boolean2(),
-    reason: string2().max(200).optional(),
-    url: string2().max(PAGE_URL_MAX_CHARS).optional(),
-    title: pageTitle.optional(),
-    errors: array(string2().max(PAGE_ERROR_MAX_CHARS)).max(RENDER_ERRORS_MAX)
-  }),
   object({ t: literal("pick-variant"), worktreeId: id }),
   object({
     t: literal("unqueue"),
@@ -7059,6 +7044,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   }),
   object({ t: literal("handoff-ask"), worktreeId: id, repoId: id, text: prompt.optional() }),
   object({ t: literal("agent-logout"), agent: id }),
+  object({ t: literal("agent-check"), agent: id }),
   object({ t: literal("agent-config"), agent: id, repoId: id.optional() }),
   object({ t: literal("reveal-agent-file"), agent: id, file: string2().max(64), repoId: id.optional() }),
   object({ t: literal("import-theme"), name: string2().max(300), source: string2().max(2000000) }),
@@ -8528,7 +8514,7 @@ async function turnRemoteOff(ts, daemonPort, file, was) {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.14.0",
+  version: "0.16.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -8544,6 +8530,10 @@ var package_default = {
   }
 };
 
+// ../daemon/src/agent/acp/transport.ts
+import { spawn } from "child_process";
+import { Readable, Writable } from "stream";
+
 // ../../node_modules/.bun/@agentclientprotocol+sdk@1.4.0+ab3ed8e9421bfd7b/node_modules/@agentclientprotocol/sdk/dist/schema/index.js
 var AGENT_METHODS = {
   initialize: "initialize",
@@ -12620,16 +12610,6 @@ var legacyClientNotificationMethods = new Set([
   CLIENT_METHODS.elicitation_complete
 ]);
 
-// ../daemon/src/core/errors.ts
-class UserError extends Error {
-  delivered;
-  constructor(message, about = {}) {
-    super(message);
-    this.name = "UserError";
-    this.delivered = about.delivered ?? false;
-  }
-}
-
 // ../daemon/src/core/log.ts
 var LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
 function envLevel() {
@@ -12675,131 +12655,6 @@ function fireAndForget(tag, p, what = "background task") {
   p.catch((e) => log.warn(tag, `${what} failed`, e));
 }
 
-// ../daemon/src/agent/acp/authstatus.ts
-var AUTH_STATUS_UPDATE_METHOD = "_auth/status_update";
-var KINDS = new Set(["none", "api_key", "account", "external", "gateway"]);
-function supportsLogout(caps) {
-  return !!caps?.auth?.logout;
-}
-var str = (v) => typeof v === "string" && v.trim() ? v : undefined;
-function parseAuthStatus(params) {
-  const status = params?.authStatus;
-  if (!status || typeof status !== "object")
-    return null;
-  const kind = status.kind;
-  if (!KINDS.has(kind))
-    return null;
-  const account = status.account ?? undefined;
-  const fields = account ? {
-    ...str(account.email) ? { email: str(account.email) } : {},
-    ...str(account.organization) ? { organization: str(account.organization) } : {},
-    ...str(account.plan) ? { plan: str(account.plan) } : {}
-  } : {};
-  return {
-    kind,
-    label: str(status.label) ?? (kind === "none" ? "not logged in" : "logged in"),
-    ...str(status.detail) ? { detail: str(status.detail) } : {},
-    ...Object.keys(fields).length ? { account: fields } : {}
-  };
-}
-
-// ../daemon/src/agent/accounts.ts
-class AgentAccounts {
-  d;
-  known = new Map;
-  busy = new Map;
-  onChange = null;
-  constructor(d) {
-    this.d = d;
-  }
-  observe(agentId, o) {
-    const before = this.known.get(agentId) ?? { canLogout: false, status: undefined };
-    const entry = { ...before };
-    if (o.canLogout !== undefined)
-      entry.canLogout = o.canLogout;
-    if (o.status)
-      entry.status = o.status;
-    this.known.set(agentId, entry);
-    if (before.canLogout !== entry.canLogout || !same(before.status, entry.status))
-      this.onChange?.();
-  }
-  observeLimits(agentId, limits) {
-    const before = this.known.get(agentId) ?? { canLogout: false, status: undefined };
-    const entry = { ...before, limits };
-    this.known.set(agentId, entry);
-    if (!sameLimits(before.limits, limits))
-      this.onChange?.();
-  }
-  describe(infos) {
-    return infos.map((info) => {
-      const k = this.known.get(info.id);
-      if (!k)
-        return info;
-      return {
-        ...info,
-        ...k.status ? { auth: k.status } : {},
-        ...k.canLogout ? { canLogout: true } : {},
-        ...k.limits ? { limits: k.limits } : {}
-      };
-    });
-  }
-  logout(agentId) {
-    const running = this.busy.get(agentId);
-    if (running)
-      return running;
-    const p = this.runLogout(agentId).finally(() => this.busy.delete(agentId));
-    this.busy.set(agentId, p);
-    return p;
-  }
-  async runLogout(agentId) {
-    const spec = this.d.require(agentId);
-    let pushed = null;
-    let signingOut = false;
-    const app = client({ name: "toyon" }).onNotification(AUTH_STATUS_UPDATE_METHOD, parseAuthStatus, (c) => {
-      if (c.params && signingOut)
-        pushed = c.params;
-    });
-    const link = await this.d.connect(app, spec);
-    try {
-      const init = await link.conn.agent.request(methods.agent.initialize, {
-        protocolVersion: PROTOCOL_VERSION2,
-        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },
-        clientInfo: { name: "toyon", version: "0" }
-      });
-      if (!supportsLogout(init.agentCapabilities))
-        throw new UserError(`${spec.name} cannot be signed out from here`);
-      signingOut = true;
-      await link.conn.agent.request(methods.agent.logout, {});
-      const entry = this.known.get(agentId);
-      this.known.set(agentId, { canLogout: true, ...pushed ? { status: pushed } : {} });
-      if (!entry || !same(entry.status, pushed ?? undefined))
-        this.onChange?.();
-      log.info("agents", `${agentId} signed out`);
-    } catch (e) {
-      if (e instanceof UserError)
-        throw e;
-      throw new UserError(`${spec.name} could not be signed out: ${e instanceof Error ? e.message : String(e)}`);
-    } finally {
-      await link.kill();
-    }
-  }
-}
-function sameLimits(a, b) {
-  if (!a || !b)
-    return a === b;
-  const win = (x) => x ? `${x.used}@${x.resetsAt}` : "";
-  return a.status === b.status && a.binding === b.binding && win(a.windows.five_hour) === win(b.windows.five_hour) && win(a.windows.seven_day) === win(b.windows.seven_day);
-}
-function same(a, b) {
-  if (!a || !b)
-    return a === b;
-  return a.kind === b.kind && a.label === b.label && a.detail === b.detail && a.account?.email === b.account?.email && a.account?.organization === b.account?.organization && a.account?.plan === b.account?.plan;
-}
-
-// ../daemon/src/agent/acp/transport.ts
-import { spawn } from "child_process";
-import { Readable, Writable } from "stream";
-
 // ../daemon/src/runtime/kill.ts
 var KILL_GRACE_MS = 3000;
 var EXIT_GRACE_MS = 200;
@@ -12903,6 +12758,16 @@ import { createHash } from "crypto";
 import { copyFile as copyFile2, mkdir, readFile, stat, writeFile } from "fs/promises";
 import { join as join2 } from "path";
 
+// ../daemon/src/core/errors.ts
+class UserError extends Error {
+  delivered;
+  constructor(message, about = {}) {
+    super(message);
+    this.name = "UserError";
+    this.delivered = about.delivered ?? false;
+  }
+}
+
 // ../daemon/src/agent/uploads.ts
 import { randomBytes } from "crypto";
 import { mkdirSync, readdirSync, rmSync as rmSync2 } from "fs";
@@ -13187,13 +13052,7 @@ class AttachmentStore {
       const { n: _n, ...pick } = ref;
       return pick;
     }
-    let path = null;
-    for (const at of [this.fileFor(worktreeId, ref.file), archived?.(ref.file) ?? null]) {
-      if (at && await Bun.file(at).exists()) {
-        path = at;
-        break;
-      }
-    }
+    const path = await this.locate(worktreeId, ref.file, archived);
     if (!path)
       return null;
     if (ref.kind === "paste") {
@@ -13211,6 +13070,13 @@ class AttachmentStore {
     const { name, bytes, width, height } = ref;
     return { kind: "image", upload, name, mimeType, bytes, width, height };
   }
+  async locate(worktreeId, file, archived) {
+    for (const at of [this.fileFor(worktreeId, file), archived?.(file) ?? null]) {
+      if (at && await Bun.file(at).exists())
+        return at;
+    }
+    return null;
+  }
   async write(worktreeId, file, fill) {
     const wtDir = attachmentsDirFor(this.dir, worktreeId);
     const path = join2(wtDir, file);
@@ -13595,6 +13461,37 @@ async function readCapped(req, max) {
   return Buffer.concat(chunks).toString("utf8");
 }
 
+// ../daemon/src/agent/acp/authstatus.ts
+var AUTH_STATUS_UPDATE_METHOD = "_auth/status_update";
+var KINDS = new Set(["none", "api_key", "account", "external", "gateway"]);
+function supportsLogout(caps) {
+  return !!caps?.auth?.logout;
+}
+var str = (v) => typeof v === "string" && v.trim() ? v : undefined;
+function parseAuthStatus(params) {
+  const status = params?.authStatus;
+  if (!status || typeof status !== "object")
+    return null;
+  const kind = status.kind;
+  if (!KINDS.has(kind))
+    return null;
+  const account = status.account ?? undefined;
+  const fields = account ? {
+    ...str(account.email) ? { email: str(account.email) } : {},
+    ...str(account.organization) ? { organization: str(account.organization) } : {},
+    ...str(account.plan) ? { plan: str(account.plan) } : {}
+  } : {};
+  return {
+    kind,
+    label: str(status.label) ?? (kind === "none" ? "not logged in" : "logged in"),
+    ...str(status.detail) ? { detail: str(status.detail) } : {},
+    ...Object.keys(fields).length ? { account: fields } : {}
+  };
+}
+function isAuthRequired(e) {
+  return e instanceof RequestError && e.code === -32000;
+}
+
 // ../daemon/src/agent/acp/options.ts
 var OPTION_FIELDS = { model: "model", thought_level: "effort" };
 var OPTION_CATEGORIES = Object.keys(OPTION_FIELDS);
@@ -13647,37 +13544,125 @@ function currentValues(options) {
   return out;
 }
 
-// ../daemon/src/agent/probe.ts
-class OptionProbe {
+// ../daemon/src/agent/readiness.ts
+var CHECK_COOLDOWN_MS = 30000;
+
+class AgentReadiness {
   d;
-  tried = new Set;
+  known = new Map;
+  inflight = new Map;
+  logouts = new Map;
+  onChange = null;
+  now;
   constructor(d) {
     this.d = d;
+    this.now = d.now ?? Date.now;
   }
-  async missing() {
+  entry(agentId) {
+    let e = this.known.get(agentId);
+    if (!e) {
+      e = { canLogout: false };
+      this.known.set(agentId, e);
+    }
+    return e;
+  }
+  observe(agentId, o) {
+    const e = this.entry(agentId);
+    const before = { ...e };
+    if (o.canLogout !== undefined)
+      e.canLogout = o.canLogout;
+    if (o.status) {
+      e.status = o.status;
+      if (o.status.kind !== "none")
+        delete e.failure;
+    }
+    if (before.canLogout !== e.canLogout || !same(before.status, e.status) || before.failure !== e.failure) {
+      this.onChange?.();
+    }
+  }
+  observeLimits(agentId, limits) {
+    const e = this.entry(agentId);
+    const before = e.limits;
+    e.limits = limits;
+    if (!sameLimits(before, limits))
+      this.onChange?.();
+  }
+  describe() {
+    return this.d.infos().map((info) => {
+      const e = this.known.get(info.id);
+      const models = this.d.options(info.id, "model");
+      const efforts = this.d.options(info.id, "thought_level");
+      return {
+        ...info,
+        ...models.length > 0 ? { models } : {},
+        ...efforts.length > 0 ? { efforts } : {},
+        ...this.d.quick(info.id) ? { quick: true } : {},
+        ...e?.status ? { auth: e.status } : {},
+        ...e?.canLogout ? { canLogout: true } : {},
+        ...e?.limits ? { limits: e.limits } : {},
+        ...e?.failure ? { checkFailed: e.failure } : {}
+      };
+    });
+  }
+  positive(agentId) {
+    const e = this.known.get(agentId);
+    return this.d.options(agentId, "model").length > 0 && !e?.failure && e?.status?.kind !== "none";
+  }
+  check(agentId) {
+    const info = this.d.infos().find((a) => a.id === agentId);
+    if (!info?.available)
+      return Promise.resolve();
+    const running = this.inflight.get(agentId);
+    if (running)
+      return running;
+    if (this.positive(agentId))
+      return Promise.resolve();
+    const e = this.known.get(agentId);
+    if (e?.checkedAt !== undefined && this.now() - e.checkedAt < CHECK_COOLDOWN_MS)
+      return Promise.resolve();
+    const p = this.run(agentId).finally(() => {
+      if (this.inflight.get(agentId) === p)
+        this.inflight.delete(agentId);
+    });
+    this.inflight.set(agentId, p);
+    return p;
+  }
+  async checkMissing() {
     for (const a of this.d.infos()) {
-      if (!a.available || this.tried.has(a.id) || this.d.known(a.id))
-        continue;
-      this.tried.add(a.id);
-      await this.probe(a.id);
+      if (a.available && this.d.options(a.id, "model").length === 0)
+        await this.check(a.id);
     }
   }
-  async probe(agentId) {
-    const tag = `probe:${agentId}`;
-    const app = client({ name: "toyon" }).onNotification(methods.client.session.update, () => {});
+  async run(agentId) {
+    const tag = `check:${agentId}`;
+    const found = {};
+    let spec;
+    try {
+      spec = this.d.require(agentId);
+    } catch (e) {
+      this.finish(agentId, firstLine(e), found);
+      return;
+    }
+    const app = client({ name: "toyon" }).onNotification(methods.client.session.update, () => {}).onNotification(AUTH_STATUS_UPDATE_METHOD, parseAuthStatus, (c) => {
+      if (c.params)
+        found.status = c.params;
+    });
     let link;
     try {
-      link = await this.d.connect(app, this.d.require(agentId));
+      link = await this.d.connect(app, spec);
     } catch (e) {
-      log.warn(tag, "could not start the agent to read its models", e);
+      log.warn(tag, "could not start the agent", e);
+      this.finish(agentId, firstLine(e), found);
       return;
     }
+    let failure;
     try {
       const init = await link.conn.agent.request(methods.agent.initialize, {
         protocolVersion: PROTOCOL_VERSION2,
         clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },
         clientInfo: { name: "toyon", version: "0" }
       });
+      found.canLogout = supportsLogout(init.agentCapabilities);
       const s = await link.conn.agent.request(methods.agent.session.new, { cwd: this.d.cwd, mcpServers: [] });
       for (const [category, opt] of readOptions(s.configOptions))
         this.d.learned(agentId, category, opt.choices);
@@ -13687,18 +13672,97 @@ class OptionProbe {
         });
       }
     } catch (e) {
-      log.info(tag, `could not read its models before a worktree runs it: ${e instanceof Error ? e.message : String(e)}`);
+      failure = isAuthRequired(e) ? spec.loginHint : firstLine(e);
+      log.info(tag, `could not read its models: ${failure}`);
     } finally {
       link.conn.close();
       await link.kill();
     }
+    this.finish(agentId, failure, found);
+  }
+  finish(agentId, failure, found) {
+    const e = this.entry(agentId);
+    const before = { ...e };
+    if (found.canLogout !== undefined)
+      e.canLogout = found.canLogout;
+    if (found.status)
+      e.status = found.status;
+    e.failure = failure;
+    e.checkedAt = this.now();
+    if (before.canLogout !== e.canLogout || !same(before.status, e.status) || before.failure !== e.failure) {
+      this.onChange?.();
+    }
+  }
+  logout(agentId) {
+    const running = this.logouts.get(agentId);
+    if (running)
+      return running;
+    const prior = this.inflight.get(agentId) ?? Promise.resolve();
+    const p = prior.then(() => this.runLogout(agentId)).finally(() => {
+      this.logouts.delete(agentId);
+      this.inflight.delete(agentId);
+    });
+    this.logouts.set(agentId, p);
+    this.inflight.set(agentId, p.catch(() => {
+      return;
+    }));
+    return p;
   }
+  async runLogout(agentId) {
+    const spec = this.d.require(agentId);
+    let pushed = null;
+    let signingOut = false;
+    const app = client({ name: "toyon" }).onNotification(AUTH_STATUS_UPDATE_METHOD, parseAuthStatus, (c) => {
+      if (c.params && signingOut)
+        pushed = c.params;
+    });
+    const link = await this.d.connect(app, spec);
+    try {
+      const init = await link.conn.agent.request(methods.agent.initialize, {
+        protocolVersion: PROTOCOL_VERSION2,
+        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },
+        clientInfo: { name: "toyon", version: "0" }
+      });
+      if (!supportsLogout(init.agentCapabilities))
+        throw new UserError(`${spec.name} cannot be signed out from here`);
+      signingOut = true;
+      await link.conn.agent.request(methods.agent.logout, {});
+      const before = this.known.get(agentId);
+      this.known.set(agentId, { canLogout: true, ...pushed ? { status: pushed } : {} });
+      if (!before || !same(before.status, pushed ?? undefined) || before.failure !== undefined)
+        this.onChange?.();
+      log.info("agents", `${agentId} signed out`);
+    } catch (e) {
+      if (e instanceof UserError)
+        throw e;
+      throw new UserError(`${spec.name} could not be signed out: ${e instanceof Error ? e.message : String(e)}`);
+    } finally {
+      await link.kill();
+    }
+  }
+}
+function firstLine(e) {
+  const details = e instanceof RequestError ? e.data?.details : undefined;
+  const message = typeof details === "string" ? details : e instanceof Error ? e.message : String(e);
+  return message.replace(/^Internal error: /, "").split(`
+`)[0] ?? message;
+}
+function sameLimits(a, b) {
+  if (!a || !b)
+    return a === b;
+  const win = (x) => x ? `${x.used}@${x.resetsAt}` : "";
+  return a.status === b.status && a.binding === b.binding && win(a.windows.five_hour) === win(b.windows.five_hour) && win(a.windows.seven_day) === win(b.windows.seven_day);
+}
+function same(a, b) {
+  if (!a || !b)
+    return a === b;
+  return a.kind === b.kind && a.label === b.label && a.detail === b.detail && a.account?.email === b.account?.email && a.account?.organization === b.account?.organization && a.account?.plan === b.account?.plan;
 }
 
 // ../daemon/src/agent/registry.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, isAbsolute, join as join6, resolve as resolve3 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join7, resolve as resolve3 } from "path";
 
 // ../daemon/src/core/cloud.ts
 var enabled = process.env.TOYON_CLOUD === "1";
@@ -14180,9 +14244,9 @@ function opencodeEnv() {
 }
 
 // ../daemon/src/agent/sandbox.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2, tmpdir } from "os";
-import { join as join5, resolve as resolve2 } from "path";
+import { join as join6, resolve as resolve2 } from "path";
 
 // ../daemon/src/core/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -14307,6 +14371,76 @@ function within2(path, root) {
   return path === root || path.startsWith(root + sep);
 }
 
+// ../daemon/src/agent/planDoc.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename2, isAbsolute, join as join5, relative, sep as sep2 } from "path";
+var PLANS_DIR = join5(".toyon", "plans");
+var PLAN_NAME = /^[A-Za-z0-9][\w.-]*\.md$/;
+function isPlanPath(rel) {
+  return rel.startsWith(`${PLANS_DIR}/`) && PLAN_NAME.test(rel.slice(PLANS_DIR.length + 1));
+}
+function ownPlanPath(cwd, file) {
+  const dir = canonical(join5(cwd, PLANS_DIR));
+  const abs = canonical(isAbsolute(file) ? file : join5(cwd, file));
+  if (!within2(abs, dir) || relative(dir, abs).includes(sep2))
+    return null;
+  return PLAN_NAME.test(basename2(abs)) ? join5(PLANS_DIR, basename2(abs)) : null;
+}
+async function excludePlans(cwd) {
+  await excludeFromGit(cwd, `${PLANS_DIR}/`);
+}
+function lastNumber(dir) {
+  if (!existsSync7(dir))
+    return 0;
+  let max = 0;
+  for (const name of readdirSync3(dir)) {
+    const n = Number(/^(\d+)\.md$/.exec(name)?.[1]);
+    if (n > max)
+      max = n;
+  }
+  return max;
+}
+function sameAsLast(cwd, rel, markdown) {
+  try {
+    return readFileSync6(join5(cwd, rel), "utf8").trim() === markdown.trim();
+  } catch (e) {
+    log.warn(cwd, `could not read ${rel}`, e);
+    return false;
+  }
+}
+async function writePlanDoc(cwd, markdown) {
+  const dir = join5(cwd, PLANS_DIR);
+  const last = lastNumber(dir);
+  if (last > 0) {
+    const newest = join5(PLANS_DIR, `${last}.md`);
+    if (sameAsLast(cwd, newest, markdown))
+      return newest;
+  }
+  const rel = join5(PLANS_DIR, `${last + 1}.md`);
+  try {
+    mkdirSync4(dir, { recursive: true });
+    writeFileSync3(join5(cwd, rel), markdown.endsWith(`
+`) ? markdown : `${markdown}
+`);
+  } catch (e) {
+    log.warn(cwd, `could not write ${rel}; the plan stays on the card`, e);
+    return null;
+  }
+  await excludePlans(cwd);
+  return rel;
+}
+function planEdited(cwd, rel, proposed) {
+  const file = join5(cwd, rel);
+  if (!existsSync7(file))
+    return false;
+  try {
+    return readFileSync6(file, "utf8").trim() !== proposed.trim();
+  } catch (e) {
+    log.warn(cwd, `could not read ${rel}`, e);
+    return false;
+  }
+}
+
 // ../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"];
@@ -14335,9 +14469,10 @@ async function prepareLaunch(cwd, spec) {
     log.warn(cwd, `agent ${spec.id} runs without an OS sandbox`);
   return { bounds, env: setup?.env ?? {} };
 }
-var SETTINGS_REL = join5(".claude", "settings.local.json");
+var SETTINGS_REL = join6(".claude", "settings.local.json");
 function claudeLocalSettings(b) {
   return {
+    plansDirectory: PLANS_DIR,
     sandbox: {
       enabled: true,
       failIfUnavailable: true,
@@ -14349,12 +14484,12 @@ function claudeLocalSettings(b) {
   };
 }
 async function writeClaudeLocalSettings(cwd, b) {
-  const file = join5(cwd, SETTINGS_REL);
-  mkdirSync4(join5(cwd, ".claude"), { recursive: true });
+  const file = join6(cwd, SETTINGS_REL);
+  mkdirSync5(join6(cwd, ".claude"), { recursive: true });
   let existing = {};
-  if (existsSync7(file)) {
+  if (existsSync8(file)) {
     try {
-      const parsed = JSON.parse(readFileSync6(file, "utf8"));
+      const parsed = JSON.parse(readFileSync7(file, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
         existing = parsed;
     } catch (e) {
@@ -14367,13 +14502,20 @@ async function writeClaudeLocalSettings(cwd, b) {
   const perms = existing.permissions && typeof existing.permissions === "object" ? existing.permissions : {};
   const theirs = Array.isArray(perms.deny) ? perms.deny.filter((r) => typeof r === "string") : [];
   const deny = uniq2([...theirs, ...ours.permissions.deny]);
-  const next = { ...existing, sandbox: ours.sandbox, permissions: { ...perms, ...ours.permissions, deny } };
+  const next = {
+    ...existing,
+    sandbox: ours.sandbox,
+    permissions: { ...perms, ...ours.permissions, deny },
+    plansDirectory: ours.plansDirectory
+  };
   const tmp = `${file}.tmp`;
-  writeFileSync3(tmp, `${JSON.stringify(next, null, 2)}
+  writeFileSync4(tmp, `${JSON.stringify(next, null, 2)}
 `);
   renameSync(tmp, file);
-  if (existsSync7(join5(cwd, ".git")))
+  if (existsSync8(join6(cwd, ".git"))) {
     await excludeFromGit(cwd, SETTINGS_REL);
+    await excludePlans(cwd);
+  }
 }
 
 // ../daemon/src/agent/registry.ts
@@ -14432,14 +14574,30 @@ var BUILTIN_AGENTS = [
     systemPrompt: "prompt-prefix",
     modes: { plan: "plan", build: "build" },
     quickModel: opencodeQuickModel,
-    loginHint: "OpenCode has no provider logged in; run `opencode auth login` in the terminal"
+    loginHint: "OpenCode has no provider logged in; run opencode auth login in the terminal"
   }
 ];
+function installErrorLine(stderr) {
+  const lines = stderr.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  const first = lines.find((l) => l.startsWith("error:"))?.slice("error:".length).trim();
+  const line = first || lines.at(-1) || "no output";
+  if (UNTRUSTED_CA.test(line))
+    return `${line}. A certificate bun does not trust, usually a proxy's: set NODE_EXTRA_CA_CERTS to its file and restart Toyon`;
+  return line;
+}
+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);
-  return { ok: r.ok, err: r.err.split(`
-`).slice(-3).join(" ") };
+  const r = await run(process.execPath, ["install", "--no-progress", "--no-summary"], dir, {
+    NO_COLOR: "1",
+    FORCE_COLOR: "0"
+  });
+  return { ok: r.ok, err: r.ok ? "" : installErrorLine(r.err) };
 };
+var RETRY_AFTER_MS = 30000;
+var RETRY_CAP_MS = 60 * 60000;
+var retryWindow = (retries) => Math.min(RETRY_AFTER_MS * 2 ** retries, RETRY_CAP_MS);
+var failedReason = (why) => `install failed: ${why}`;
 function jsRuntime() {
   if (process.env.TOYON_ACP_RUNTIME === "node") {
     const node = Bun.which("node");
@@ -14455,15 +14613,18 @@ class AgentRegistry {
   installer;
   host;
   sandbox;
+  now;
   specs = new Map;
   installing = new Map;
   installErrors = new Map;
+  failures = new Map;
   onChange = null;
-  constructor(specs, dir, installer = bunInstall, host = hostTraits(), sandbox = { problem: () => null }) {
+  constructor(specs, dir, installer = bunInstall, host = hostTraits(), sandbox = { problem: () => null }, now = Date.now) {
     this.dir = dir;
     this.installer = installer;
     this.host = host;
     this.sandbox = sandbox;
+    this.now = now;
     for (const s of specs)
       this.specs.set(s.id, s);
   }
@@ -14500,43 +14661,47 @@ class AgentRegistry {
     const name = this.packageName(spec);
     if (!name || spec.run.kind === "command")
       return null;
-    const pkgDir = join6(this.dir, spec.id, "node_modules", name);
+    const pkgDir = join7(this.dir, spec.id, "node_modules", name);
     if (spec.run.kind === "npm-native") {
-      const bin = join6(pkgDir, spec.run.bin);
-      return existsSync8(bin) ? bin : null;
+      const bin = join7(pkgDir, spec.run.bin);
+      return existsSync9(bin) ? bin : null;
     }
-    const pkgJson = join6(pkgDir, "package.json");
-    if (!existsSync8(pkgJson))
+    const pkgJson = join7(pkgDir, "package.json");
+    if (!existsSync9(pkgJson))
       return null;
     try {
-      const meta = JSON.parse(readFileSync7(pkgJson, "utf8"));
+      const meta = JSON.parse(readFileSync8(pkgJson, "utf8"));
       const rel = typeof meta.bin === "string" ? meta.bin : meta.bin?.[spec.run.bin];
       if (!rel)
         return null;
-      const script = join6(dirname3(pkgJson), rel);
-      return existsSync8(script) ? script : null;
+      const script = join7(dirname3(pkgJson), rel);
+      return existsSync9(script) ? script : null;
     } catch (e) {
       log.warn("agents", `cannot read ${pkgJson}`, e);
       return null;
     }
   }
   unavailable(spec) {
-    return this.notInstalled(spec) ?? (spec.confinement === "none" ? null : this.sandbox.problem());
-  }
-  notInstalled(spec) {
-    if (spec.run.kind !== "command") {
-      if (!this.packageName(spec))
-        return `no build for ${this.host.platform} ${this.host.arch}`;
-      if (this.installed(spec))
-        return null;
-      if (this.installing.has(spec.id))
-        return "installing";
-      return this.installErrors.get(spec.id) ?? (spec.onDemand ? "not installed" : "not installed yet");
-    }
-    const cmd = spec.run.command;
-    if (isAbsolute(cmd) ? existsSync8(cmd) : Bun.which(cmd))
-      return null;
-    return `${cmd} not found on PATH`;
+    return this.status(spec).reason;
+  }
+  status(spec) {
+    const boxed = spec.confinement === "none" ? null : this.sandbox.problem();
+    if (spec.run.kind === "command") {
+      const cmd = spec.run.command;
+      const found = isAbsolute2(cmd) ? existsSync9(cmd) : Bun.which(cmd);
+      return { reason: found ? boxed : `${cmd} not found on PATH` };
+    }
+    if (!this.packageName(spec))
+      return { reason: `no build for ${this.host.platform} ${this.host.arch}` };
+    if (this.installed(spec))
+      return { reason: boxed };
+    if (this.installing.has(spec.id))
+      return { reason: "installing" };
+    const failed = this.installErrors.get(spec.id);
+    const missing = failed !== undefined ? failedReason(failed) : spec.onDemand ? "not installed" : "not installed yet";
+    if (boxed)
+      return { reason: failed !== undefined ? `${missing}; ${boxed}` : boxed };
+    return { reason: missing, install: failed !== undefined ? { failed } : "missing" };
   }
   command(spec) {
     const why = this.unavailable(spec);
@@ -14564,23 +14729,29 @@ class AgentRegistry {
     const running = this.installing.get(id);
     if (running)
       return running;
-    if (this.installed(spec) && this.installedVersion(spec) === spec.run.version)
+    if (this.installed(spec) && this.installedVersion(spec) === spec.run.version) {
+      this.installErrors.delete(id);
+      this.failures.delete(id);
       return Promise.resolve();
+    }
     const { version } = spec.run;
-    const dir = join6(this.dir, id);
+    const dir = join7(this.dir, id);
     const p = (async () => {
-      mkdirSync5(dir, { recursive: true });
-      writeFileSync4(join6(dir, "package.json"), `${JSON.stringify({ name: `toyon-agent-${id}`, private: true, dependencies: { [pkg]: version } }, null, 2)}
+      try {
+        mkdirSync6(dir, { recursive: true });
+        writeFileSync5(join7(dir, "package.json"), `${JSON.stringify({ name: `toyon-agent-${id}`, private: true, dependencies: { [pkg]: version } }, null, 2)}
 `);
-      log.info("agents", `installing ${pkg}@${version} for ${id}`);
-      const r = await this.installer(dir, pkg, version);
-      if (r.ok && this.installed(spec)) {
-        this.installErrors.delete(id);
-        log.info("agents", `${id} ready`);
-      } else {
-        const why = `install failed: ${r.err || "no bin after install"}`;
-        this.installErrors.set(id, why);
-        log.warn("agents", `${id}: ${why}`);
+        log.info("agents", `installing ${pkg}@${version} for ${id}`);
+        const r = await this.installer(dir, pkg, version);
+        if (r.ok && this.installed(spec)) {
+          this.installErrors.delete(id);
+          this.failures.delete(id);
+          log.info("agents", `${id} ready`);
+          return;
+        }
+        this.fail(id, r.err || "no bin after install");
+      } catch (e) {
+        this.fail(id, e instanceof Error ? e.message : String(e));
       }
     })().finally(() => {
       this.installing.delete(id);
@@ -14590,13 +14761,18 @@ class AgentRegistry {
     this.onChange?.();
     return p;
   }
+  fail(id, why) {
+    this.installErrors.set(id, why);
+    this.failures.set(id, { at: this.now(), retries: this.failures.get(id)?.retries ?? 0 });
+    log.warn("agents", `${id}: ${failedReason(why)}`);
+  }
   installedVersion(spec) {
     const name = this.packageName(spec);
     if (!name)
       return null;
-    const pkgJson = join6(this.dir, spec.id, "node_modules", name, "package.json");
+    const pkgJson = join7(this.dir, spec.id, "node_modules", name, "package.json");
     try {
-      return JSON.parse(readFileSync7(pkgJson, "utf8")).version ?? null;
+      return JSON.parse(readFileSync8(pkgJson, "utf8")).version ?? null;
     } catch {
       return null;
     }
@@ -14609,22 +14785,37 @@ class AgentRegistry {
       await this.install(id);
     }
   }
+  async retryFailed() {
+    if (this.installing.size > 0)
+      return;
+    for (const [id, entry] of this.failures) {
+      if (this.now() - entry.at < retryWindow(entry.retries))
+        continue;
+      entry.retries += 1;
+      await this.install(id);
+    }
+  }
   adapters() {
     const out = [];
     for (const spec of this.list()) {
       if (spec.run.kind === "command" || !this.packageName(spec))
         continue;
       const installed = this.installed(spec) ? this.installedVersion(spec) : null;
-      const error = this.installErrors.get(spec.id);
-      if (spec.onDemand && installed === null && !error)
+      const failed = this.installErrors.get(spec.id);
+      if (spec.onDemand && installed === null && failed === undefined)
         continue;
-      out.push({ id: spec.id, installed, pinned: spec.run.version, ...error ? { error } : {} });
+      out.push({
+        id: spec.id,
+        installed,
+        pinned: spec.run.version,
+        ...failed !== undefined ? { error: failedReason(failed) } : {}
+      });
     }
     return out;
   }
   infos() {
     return this.list().map((spec) => {
-      const reason = this.unavailable(spec);
+      const { reason, install } = this.status(spec);
       return {
         id: spec.id,
         name: spec.name,
@@ -14632,8 +14823,10 @@ class AgentRegistry {
         available: !reason,
         ...reason ? { reason } : {},
         ...this.installing.has(spec.id) ? { installing: true } : {},
+        ...install !== undefined ? { install } : {},
         ...spec.onDemand ? { onDemand: true } : {},
-        sandboxed: spec.confinement !== "none"
+        sandboxed: spec.confinement !== "none",
+        loginHint: spec.loginHint
       };
     });
   }
@@ -14701,7 +14894,7 @@ function managedSpecs(specs, managed) {
   return managed.agents === null ? kept : kept.filter((s) => managed.agents?.includes(s.id));
 }
 function loadAgentRegistry(agentsFile, agentsDir, sandbox, managed = MANAGED_DEFAULTS) {
-  const specs = managed.customAgents && existsSync8(agentsFile) ? parseAgentsFile(readFileSync7(agentsFile, "utf8"), BUILTIN_AGENTS) : BUILTIN_AGENTS;
+  const specs = managed.customAgents && existsSync9(agentsFile) ? parseAgentsFile(readFileSync8(agentsFile, "utf8"), BUILTIN_AGENTS) : BUILTIN_AGENTS;
   return new AgentRegistry(managedSpecs(specs, managed), agentsDir, undefined, undefined, sandbox);
 }
 
@@ -14720,21 +14913,33 @@ function agentModeFor(spec, mode, available) {
 function modeAfterPlan(optionName) {
   return /manual/i.test(optionName) ? "ask" : "auto";
 }
+function orderPlanOptions(options) {
+  const rank = (id) => {
+    if (id === "exit-plan-default")
+      return 1;
+    if (id.startsWith("exit-plan-clear-"))
+      return 2;
+    if (id.startsWith("exit-plan-"))
+      return 0;
+    return 3;
+  };
+  return [...options].sort((a, b) => rank(a.optionId) - rank(b.optionId));
+}
 
 // ../daemon/src/agent/origins.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename2, join as join7 } from "path";
+import { basename as basename3, join as join8 } from "path";
 function commandFolders(spec, cwd, home = homedir4()) {
   if (spec.id === "claude") {
     return [
-      { origin: "project", skills: join7(cwd, ".claude", "skills"), commands: join7(cwd, ".claude", "commands") },
-      { origin: "user", skills: join7(home, ".claude", "skills"), commands: join7(home, ".claude", "commands") },
-      ...pluginPaths(spec.meta).map((p) => ({ origin: "plugin", skills: join7(p, "skills"), commands: join7(p, "commands") }))
+      { origin: "project", skills: join8(cwd, ".claude", "skills"), commands: join8(cwd, ".claude", "commands") },
+      { origin: "user", skills: join8(home, ".claude", "skills"), commands: join8(home, ".claude", "commands") },
+      ...pluginPaths(spec.meta).map((p) => ({ origin: "plugin", skills: join8(p, "skills"), commands: join8(p, "commands") }))
     ];
   }
   if (spec.id === "codex")
-    return [{ origin: "user", commands: join7(home, ".codex", "prompts") }];
+    return [{ origin: "user", commands: join8(home, ".codex", "prompts") }];
   return [];
 }
 function readCommandOrigins(folders) {
@@ -14774,23 +14979,23 @@ function pluginPaths(meta) {
 }
 function skillNames(dir) {
   return entries2(dir).flatMap((e) => {
-    const file = join7(dir, e, "SKILL.md");
-    if (!existsSync9(file))
+    const file = join8(dir, e, "SKILL.md");
+    if (!existsSync10(file))
       return [];
     return [frontMatterName(file) ?? e];
   });
 }
 function commandNames(dir) {
   return entries2(dir).flatMap((e) => {
-    const path = join7(dir, e);
+    const path = join8(dir, e);
     if (e.endsWith(".md"))
-      return [basename2(e, ".md")];
+      return [basename3(e, ".md")];
     return isDir(path) ? commandNames(path) : [];
   });
 }
 function frontMatterName(file) {
   try {
-    const text = readFileSync8(file, "utf8");
+    const text = readFileSync9(file, "utf8");
     if (!text.startsWith("---"))
       return null;
     const end = text.indexOf(`
@@ -14804,10 +15009,10 @@ function frontMatterName(file) {
   }
 }
 function entries2(dir) {
-  if (!existsSync9(dir))
+  if (!existsSync10(dir))
     return [];
   try {
-    return readdirSync3(dir).filter((e) => !e.startsWith("."));
+    return readdirSync4(dir).filter((e) => !e.startsWith("."));
   } catch (e) {
     log.warn("origins", `${dir} could not be listed`, e);
     return [];
@@ -14851,13 +15056,13 @@ function unformatOutput(output) {
 }
 
 // ../daemon/src/agent/policy.ts
-import { isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
 
 // ../daemon/src/agent/acp/background.ts
-import { existsSync as existsSync10, statSync as statSync4 } from "fs";
+import { existsSync as existsSync11, statSync as statSync4 } from "fs";
 import { open as open2 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename3, dirname as dirname4, join as join8 } from "path";
+import { basename as basename4, dirname as dirname4, join as join9 } from "path";
 var STARTED = /Command running in background with ID: (\S+)\. Output is being written to: (\S+)\./;
 function backgroundStart(input, output) {
   const flag = input && typeof input === "object" ? input.run_in_background : undefined;
@@ -14870,15 +15075,15 @@ function spawnDetached(output) {
   return output.includes("Async agent launched successfully");
 }
 function claudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join8(homedir5(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || join9(homedir5(), ".claude");
 }
 function sessionLogFor(file, configDir = claudeConfigDir()) {
   const tasks = dirname4(file);
-  if (basename3(tasks) !== "tasks")
+  if (basename4(tasks) !== "tasks")
     return null;
   const session = dirname4(tasks);
-  const path = join8(configDir, "projects", basename3(dirname4(session)), `${basename3(session)}.jsonl`);
-  return existsSync10(path) ? path : null;
+  const path = join9(configDir, "projects", basename4(dirname4(session)), `${basename4(session)}.jsonl`);
+  return existsSync11(path) ? path : null;
 }
 function taskEnd(text, toolId) {
   const at = text.indexOf(`<tool-use-id>${toolId}</tool-use-id>`);
@@ -15091,14 +15296,16 @@ function isNetworkAsk(update) {
 function isToolSearch(update) {
   return update.name === TOOL_SEARCH || asRecord2(asRecord2(update._meta).claudeCode).toolName === TOOL_SEARCH;
 }
-function toolSearchQuery(rawInput) {
+var TOOL_SEARCH_OPENING = "loading a tool";
+function toolSearchTitle(rawInput) {
   const query = asRecord2(rawInput).query;
   if (typeof query !== "string")
     return "";
   const names = /^select:(.*)$/.exec(query.trim());
   if (!names)
-    return query.trim();
-  return (names[1] ?? "").split(",").map((s) => s.trim()).filter(Boolean).join(", ");
+    return `looked for a tool: ${query.trim()}`;
+  const loaded = (names[1] ?? "").split(",").map((s) => s.trim()).filter(Boolean).join(", ");
+  return loaded ? `loaded ${loaded}` : "";
 }
 var TOYON_TOOL = new RegExp(`^(?:mcp__${TOYON_MCP_SERVER}__|${TOYON_MCP_SERVER}/)([A-Za-z0-9_-]+)$`);
 function toyonTool(update) {
@@ -15122,7 +15329,7 @@ function heading(update) {
   if (isNetworkAsk(update) && typeof host === "string")
     return { name: "", title: host, kind: "fetch" };
   if (isToolSearch(update)) {
-    return { name: TOOL_SEARCH, title: toolSearchQuery(update.rawInput) || TOOL_SEARCH, kind: "search" };
+    return { name: TOOL_SEARCH, title: toolSearchTitle(update.rawInput) || TOOL_SEARCH_OPENING, kind: "other" };
   }
   const own = toyonTool(update);
   if (own)
@@ -15254,7 +15461,7 @@ function mapUpdate(update, memos, tag, sink, background) {
         });
       }
       const refined = { ...memo.held };
-      const title = memo.name === TOOL_SEARCH ? toolSearchQuery(update.rawInput) : memo.name === HANDOFF_TOOL ? update.rawInput !== undefined ? toyonTitle(HANDOFF_TOOL, update.rawInput, update.title) : undefined : update.title;
+      const title = memo.name === TOOL_SEARCH ? toolSearchTitle(update.rawInput) : memo.name === HANDOFF_TOOL ? update.rawInput !== undefined ? toyonTitle(HANDOFF_TOOL, update.rawInput, update.title) : undefined : update.title;
       if (title && title !== memo.title)
         refined.title = memo.title = title;
       if (update.name && update.name !== memo.name && toyonTool(update) !== memo.name)
@@ -15455,7 +15662,7 @@ function decide(req, bounds, cwd, mode = "auto", sandboxed = true) {
     return { kind: "allow" };
   }
   for (const raw of paths) {
-    const target = canonical(isAbsolute2(raw) ? raw : resolve4(cwd, raw));
+    const target = canonical(isAbsolute3(raw) ? raw : resolve4(cwd, raw));
     if (bounds.denyRead.some((d) => within2(target, d))) {
       return {
         kind: "reject",
@@ -15521,7 +15728,6 @@ var SYSTEM_APPEND = [
   "`@some/path` in a message means read that file or directory first; `@changes` means this worktree's uncommitted files, which `git status` lists.",
   'Toyon previews the project in a browser panel by running the commands in its settings file, .toyon/settings.json (or toyon.json at the repo root, in a repo that keeps it there), shaped like {"setup": ["bun install"], "run": {"web": "bun run dev --port $PORT"}, "check": "bun run check", "land": {"route": "merge"}}: setup runs once in every new worktree, 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.",
-  "To see whether a page renders without throwing, call the `preview` tool with its path when you have one: a browser the user has open loads it beside what they see and reports what it threw.",
   "When you scaffold a project, write its .gitignore (dependencies, build output, local env files) before installing anything, so an install never leaves thousands of untracked files for the user to wade through or commit.",
   "When you scaffold a project or change how it installs or starts, finish by updating the settings file Toyon already reads, or writing .toyon/settings.json when there is none, so the preview can run it."
 ].join(" ");
@@ -15534,7 +15740,6 @@ function failedRun(f) {
     case "conflict":
       return f.step;
     case "preview":
-    case "page":
       return;
   }
 }
@@ -15550,8 +15755,6 @@ function fixPrompt(f) {
       return commandFixPrompt(f.command);
     case "preview":
       return procFixPrompt(f.procs, f.log);
-    case "page":
-      return pageFixPrompt(f.errors);
   }
 }
 var WHY_COMMAND_CHARS = 60;
@@ -15570,20 +15773,8 @@ function fixWhy(f) {
     }
     case "preview":
       return "the dev server is not reachable";
-    case "page":
-      return "the preview threw";
   }
 }
-function pageFixPrompt(errors) {
-  return [
-    "Since your last edits the preview threw this in the user's browser:",
-    "",
-    ...errors.map((e) => `- ${e}`),
-    "",
-    "Find the cause and fix it, inside this worktree. If your change did not cause it, say what did instead of changing anything."
-  ].join(`
-`);
-}
 function failureContext(f) {
   const run = failedRun(f);
   if (!run)
@@ -15789,11 +15980,11 @@ ${a.text}
 }
 
 // ../daemon/src/agent/transcript.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { appendFile } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function transcriptPathFor(transcriptsDir, worktreeId) {
-  return join9(transcriptsDir, `${worktreeId}.jsonl`);
+  return join10(transcriptsDir, `${worktreeId}.jsonl`);
 }
 function coalesce(entries) {
   const out = [];
@@ -15847,7 +16038,7 @@ class Transcript {
     this.seq = (this.entries.at(-1)?.seq ?? -1) + 1;
   }
   read() {
-    return existsSync11(this.path) ? parseTranscript(readFileSync9(this.path, "utf8"), this.tag) : [];
+    return existsSync12(this.path) ? parseTranscript(readFileSync10(this.path, "utf8"), this.tag) : [];
   }
   append(event) {
     const entry = { seq: this.seq++, event };
@@ -16424,6 +16615,7 @@ class AcpSession {
     this.queue = [];
     this.steered = [];
     this.queueChanged();
+    this.cancelAsks("expired");
     this.stop();
     await this.dropConn("closing");
     await this.log.flush();
@@ -16619,12 +16811,7 @@ class AcpSession {
     this.emit({ type: "turn-end", stopReason: mapStopReason(res.stopReason), ts: Date.now() });
   }
   contextFor(item) {
-    return ambientBlock([
-      ...item.context ?? [],
-      this.d.preview?.(),
-      item.asked === "page" ? undefined : this.d.pageErrors?.(),
-      ...this.landedSince()
-    ]);
+    return ambientBlock([...item.context ?? [], this.d.preview?.(), this.d.pageErrors?.(), ...this.landedSince()]);
   }
   landedSince() {
     const entries = this.log.entries;
@@ -16864,6 +17051,9 @@ class AcpSession {
     }
     if (params.update.sessionUpdate === "current_mode_update") {
       live.modeId = params.update.currentModeId;
+      const planId = agentModeFor(live.conn.spec, "plan", live.modeIds ?? undefined);
+      if (planId && live.modeId === planId && this.mode() !== "plan")
+        this.d.setMode?.("plan");
       return;
     }
     if (params.update.sessionUpdate === "config_option_update") {
@@ -16935,8 +17125,9 @@ class AcpSession {
     const plan = params.toolCall.kind === "switch_mode";
     const parts = permissionParts(params);
     const detail = parts.detail ?? "";
-    const planPath = plan ? await this.d.onPlan?.(detail) ?? null : null;
-    const offered = plan ? params.options : params.options.filter((o) => o.kind !== "allow_always");
+    const ownFile = plan ? stringField(params.toolCall.rawInput, "planFilePath") : undefined;
+    const planPath = plan ? await this.d.onPlan?.(detail, ownFile) ?? null : null;
+    const offered = plan ? orderPlanOptions(params.options) : params.options.filter((o) => o.kind !== "allow_always");
     const choices = offered.map((o) => ({ id: o.optionId, name: o.name, kind: o.kind }));
     return this.openAsk((id) => ({
       type: "agent-permission",
@@ -17022,9 +17213,9 @@ class AcpSession {
     const text = headers.length === 1 ? `with my answer to "${headers[0]}"` : "with my answers";
     this.post(text, { attachments: followUp.attachments });
   }
-  cancelAsks() {
+  cancelAsks(outcome = "cancelled") {
     for (const ask of [...this.asks.values()])
-      ask.settle("cancelled");
+      ask.settle(outcome);
   }
   syncStatus() {
     if (this.status === "error")
@@ -17106,9 +17297,6 @@ class AcpSession {
     this.noteProcess(conn.link, false);
   }
 }
-function isAuthRequired(e) {
-  return e instanceof RequestError && e.code === -32000;
-}
 function takesHttpMcp(init) {
   const http = init.agentCapabilities?.mcpCapabilities?.http;
   return http === true || typeof http === "object" && http !== null;
@@ -17185,66 +17373,6 @@ function sameCommands(a, b) {
   return a.length === b.length && a.every((c, i) => c.name === b[i]?.name && c.description === b[i]?.description && c.hint === b[i]?.hint && c.origin === b[i]?.origin);
 }
 
-// ../daemon/src/agent/planDoc.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
-import { join as join10 } from "path";
-var PLANS_DIR = join10(".toyon", "plans");
-var PLAN_NAME = /^(\d+)\.md$/;
-function isPlanPath(rel) {
-  return rel.startsWith(`${PLANS_DIR}/`) && PLAN_NAME.test(rel.slice(PLANS_DIR.length + 1));
-}
-function lastNumber(dir) {
-  if (!existsSync12(dir))
-    return 0;
-  let max = 0;
-  for (const name of readdirSync4(dir)) {
-    const n = Number(PLAN_NAME.exec(name)?.[1]);
-    if (n > max)
-      max = n;
-  }
-  return max;
-}
-function sameAsLast(cwd, rel, markdown) {
-  try {
-    return readFileSync10(join10(cwd, rel), "utf8").trim() === markdown.trim();
-  } catch (e) {
-    log.warn(cwd, `could not read ${rel}`, e);
-    return false;
-  }
-}
-async function writePlanDoc(cwd, markdown) {
-  const dir = join10(cwd, PLANS_DIR);
-  const last = lastNumber(dir);
-  if (last > 0) {
-    const newest = join10(PLANS_DIR, `${last}.md`);
-    if (sameAsLast(cwd, newest, markdown))
-      return newest;
-  }
-  const rel = join10(PLANS_DIR, `${last + 1}.md`);
-  try {
-    mkdirSync6(dir, { recursive: true });
-    writeFileSync5(join10(cwd, rel), markdown.endsWith(`
-`) ? markdown : `${markdown}
-`);
-  } catch (e) {
-    log.warn(cwd, `could not write ${rel}; the plan stays on the card`, e);
-    return null;
-  }
-  await excludeFromGit(cwd, `${PLANS_DIR}/`);
-  return rel;
-}
-function planEdited(cwd, rel, proposed) {
-  const file = join10(cwd, rel);
-  if (!existsSync12(file))
-    return false;
-  try {
-    return readFileSync10(file, "utf8").trim() !== proposed.trim();
-  } catch (e) {
-    log.warn(cwd, `could not read ${rel}`, e);
-    return false;
-  }
-}
-
 // ../daemon/src/runtime/forward.ts
 var POLL_MS2 = 100;
 var HOLD_MS = 60000;
@@ -18458,8 +18586,8 @@ function defaultAgent(wt, d, preview, onProcess) {
     onEvent: (event, seq) => d.hub.emit("agent", wt.id, seq, event),
     onStatus: (status) => d.hub.emit("agentStatus", wt.id, status),
     beforeTurn: async () => d.turnStarting?.(wt.id),
-    onAuth: (agentId, o) => d.accounts?.observe(agentId, o),
-    onLimits: (agentId, limits) => d.accounts?.observeLimits(agentId, limits),
+    onAuth: (agentId, o) => d.readiness?.observe(agentId, o),
+    onLimits: (agentId, limits) => d.readiness?.observeLimits(agentId, limits),
     seedCommands: () => d.state.cachedCommands(d.state.requireWorktree(wt.id).agent ?? "", wt.repoId),
     onCommandsLearned: (commands) => d.state.setCachedCommands(d.state.requireWorktree(wt.id).agent ?? "", wt.repoId, commands),
     commandOrigins: () => readCommandOrigins(commandFolders(spec(), wt.path)),
@@ -18468,13 +18596,14 @@ function defaultAgent(wt, d, preview, onProcess) {
       if (d.state.setMode(wt.id, mode))
         d.hub.emit("worktreesChanged");
     },
-    onPlan: async (markdown) => {
+    onPlan: async (markdown, ownFile) => {
       const w = d.state.worktree(wt.id);
       if (w && !w.planned) {
         w.planned = true;
         d.state.save();
       }
-      const path = markdown.trim() ? await writePlanDoc(wt.path, markdown) : null;
+      const own = ownFile ? ownPlanPath(wt.path, ownFile) : null;
+      const path = own ?? (markdown.trim() ? await writePlanDoc(wt.path, markdown) : null);
       const fresh = path ? d.state.worktree(wt.id) : undefined;
       if (fresh && path && fresh.plan !== path) {
         fresh.plan = path;
@@ -19504,7 +19633,7 @@ var LAND_ASK = [
   "Line 2: blank",
   "Line 3: Recap: one sentence under 20 words for the user coming back to this task, saying what the task is and then what just happened or what to do next. Skip root-cause narrative, fix internals and secondary to-dos.",
   "Line 4: blank",
-  "Line 5: a commit subject under 60 characters, lowercase, imperative, in the style of the recent subjects when given",
+  "Line 5: a commit subject under 60 characters, lowercase, imperative, naming what the diff summary says the message is for, in the style of the recent subjects when given",
   "Line 6: blank",
   "Then: a short body, 1 to 4 plain sentences on what changed and why. No markdown, no bullets, no dashes as punctuation."
 ].join(`
@@ -19512,17 +19641,25 @@ var LAND_ASK = [
 var LAND_TURNS = 4;
 var LAND_CHARS = 5000;
 function landPrompt(i) {
-  const head = [LAND_ASK, "", `Task: ${clip(i.title, 200)}`];
-  if (i.firstAsk)
-    head.push(`First request: ${clip(i.firstAsk, 300)}`);
+  const own = i.diffStat.trim();
+  const committed = i.committedStat?.trim() ?? "";
+  const head = [LAND_ASK, ""];
+  if (own && i.earlier) {
+    head.push(`Task, as the worktree is titled; background, since the branch committed or landed work before: ${clip(i.title, 200)}`);
+    if (i.firstAsk)
+      head.push(`First request here, which the earlier work may have answered: ${clip(i.firstAsk, 300)}`);
+  } else {
+    head.push(`Task: ${clip(i.title, 200)}`);
+    if (i.firstAsk)
+      head.push(`First request: ${clip(i.firstAsk, 300)}`);
+  }
   if (i.recentSubjects.length)
     head.push(`Recent commit subjects:
 ${i.recentSubjects.map((s) => `  ${s}`).join(`
 `)}`);
   if (i.note?.trim())
     head.push(`Note from the user for the commit message, to be reflected in its wording: ${clip(i.note.trim(), 500)}`);
-  const diff = `Diff summary:
-${i.diffStat.trim() || "(none)"}`;
+  const diff = diffBlock(own, committed);
   let blocks = turnBlocks(i.turns);
   const size = () => [...head, "", ...blocks, "", diff].join(`
 
@@ -19534,6 +19671,22 @@ ${i.diffStat.trim() || "(none)"}`;
 
 `), diff].join(`
 
+`);
+}
+function diffBlock(own, committed) {
+  if (!own && !committed)
+    return `Diff summary:
+(none)`;
+  const parts = [];
+  if (own)
+    parts.push(`What this commit will contain, which is all the message describes:
+${own}`);
+  if (committed)
+    parts.push(own ? `Already committed on this branch, context only, not what the message describes:
+${committed}` : `Nothing is uncommitted; the message is for the branch's commits as one:
+${committed}`);
+  return parts.join(`
+
 `);
 }
 function turnBlocks(turns) {
@@ -19743,10 +19896,12 @@ function makePlanner(agents) {
 }
 
 // ../daemon/src/agent/transcriptForward.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "fs";
 import { join as join12 } from "path";
+var FORWARD_STEP = "1";
+var MARK = '"page';
 function forwardLine(line) {
-  if (!line.includes('"page-error"'))
+  if (!line.includes(MARK))
     return null;
   let entry;
   try {
@@ -19755,31 +19910,35 @@ function forwardLine(line) {
     return null;
   }
   const e = entry.event;
-  if (e?.type !== "page-error" || Array.isArray(e.errors) || typeof e.message !== "string")
-    return null;
-  const { message, ...rest } = e;
-  return JSON.stringify({ ...entry, event: { ...rest, errors: [message] } });
+  if (e?.type === "page-error")
+    return { drop: true };
+  if (e?.type === "fix-asked" && e.kind === "page")
+    return { line: JSON.stringify({ ...entry, event: { ...e, kind: "command" } }) };
+  return null;
 }
 function forwardText(text) {
   let changed = 0;
-  const lines = text.split(`
-`).map((line) => {
+  const lines = [];
+  for (const line of text.split(`
+`)) {
     const next = forwardLine(line);
     if (next === null)
-      return line;
-    changed++;
-    return next;
-  });
+      lines.push(line);
+    else {
+      changed++;
+      if ("line" in next)
+        lines.push(next.line);
+    }
+  }
   return { text: changed ? lines.join(`
 `) : text, changed };
 }
-function forwardTranscripts(dir) {
+function forwardTranscripts(dirs, stamp) {
+  if (readStamp(stamp) === FORWARD_STEP)
+    return;
   let files = 0;
   let rows = 0;
-  for (const name of readdirSync5(dir)) {
-    if (!name.endsWith(".jsonl"))
-      continue;
-    const path = join12(dir, name);
+  for (const path of dirs.flatMap(transcriptsUnder)) {
     const { text, changed } = forwardText(readFileSync11(path, "utf8"));
     if (!changed)
       continue;
@@ -19789,22 +19948,44 @@ function forwardTranscripts(dir) {
     files++;
     rows += changed;
   }
+  writeFileSync6(stamp, FORWARD_STEP);
   if (files)
-    log.info("transcripts", `rewrote ${rows} page-error row(s) in ${files} transcript(s) to the list shape`);
+    log.info("transcripts", `moved ${rows} row(s) in ${files} transcript(s) past the preview-threw row`);
+}
+function readStamp(stamp) {
+  try {
+    return readFileSync11(stamp, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+function transcriptsUnder(dir) {
+  const found = [];
+  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name.endsWith(".jsonl"))
+      found.push(join12(dir, entry.name));
+    else if (entry.isDirectory()) {
+      const inner = join12(dir, entry.name, "transcript.jsonl");
+      if (existsSync14(inner))
+        found.push(inner);
+    }
+  }
+  return found;
 }
 
 // ../daemon/src/core/assets.ts
-import { existsSync as existsSync14, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync5 } from "fs";
+import { existsSync as existsSync15, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync5 } from "fs";
 import { join as join13, resolve as resolve5 } from "path";
 function locateAssets(here, env = process.env) {
-  const packaged = existsSync14(join13(here, "shell", "index.html"));
+  const packaged = existsSync15(join13(here, "shell", "index.html"));
   return {
     shellDist: env.TOYON_SHELL_DIST ?? (packaged ? join13(here, "shell") : join13(here, "../../shell/dist")),
     bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join13(here, "bridge.js") : join13(here, "../../bridge/dist/bridge.js")),
     helperStub: packaged ? join13(here, "helper-stub") : join13(here, "../dist/helper-stub"),
     cliEntry: packaged ? join13(here, "cli.js") : join13(here, "../../cli/src/cli.ts"),
     sourceRoot: packaged ? null : resolve5(here, "../../.."),
-    packageJson: packaged ? join13(here, "..", "package.json") : null
+    packageJson: packaged ? join13(here, "..", "package.json") : null,
+    changelog: packaged ? join13(here, "CHANGELOG.md") : resolve5(here, "../../../CHANGELOG.md")
   };
 }
 var KEEP_MS = 3 * 24 * 60 * 60 * 1000;
@@ -20263,7 +20444,7 @@ class KeepAwake {
 }
 
 // ../daemon/src/core/dialog.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { homedir as homedir6 } from "os";
 var PROMPTS = {
   location: "Choose where the new project goes",
@@ -20281,7 +20462,7 @@ function folderDialog() {
   let cancelled = false;
   const ask = async (start, purpose) => {
     const typed = start === "~" || start.startsWith("~/") ? `${homedir6()}${start.slice(1)}` : start;
-    const from = typed.startsWith("/") && existsSync15(typed) ? typed : homedir6();
+    const from = typed.startsWith("/") && existsSync16(typed) ? typed : homedir6();
     cancelled = false;
     const p = Bun.spawn(["osascript", ...SCRIPT.flatMap((line) => ["-e", line]), PROMPTS[purpose], from], {
       stdout: "pipe",
@@ -20358,9 +20539,9 @@ class GrantCodes {
 
 // ../daemon/src/core/helper.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { chmod, copyFile as copyFile3, mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename4, dirname as dirname5, join as join14 } from "path";
+import { basename as basename5, dirname as dirname5, join as join14 } from "path";
 var EXECUTABLE = "Toyon";
 function helperWanted(where) {
   return where.platform === "darwin" && !where.cloud && where.port === DAEMON_DEFAULT_PORT && where.home === undefined;
@@ -20439,7 +20620,7 @@ class Helper {
   }
   async write() {
     const { spec } = this;
-    if (!existsSync16(spec.stub))
+    if (!existsSync17(spec.stub))
       return "skipped";
     const stubHash = createHash3("sha256").update(await readFile2(spec.stub)).digest("hex").slice(0, 16);
     const { plist, script } = helperFiles(spec, stubHash);
@@ -20447,7 +20628,7 @@ class Helper {
     const resources = join14(contents, "Resources");
     const stub = join14(contents, "MacOS", EXECUTABLE);
     const scriptFile = join14(resources, "launch.sh");
-    if (existsSync16(stub) && existsSync16(scriptFile) && await readFile2(scriptFile, "utf8") === script)
+    if (existsSync17(stub) && existsSync17(scriptFile) && await readFile2(scriptFile, "utf8") === script)
       return "kept";
     await mkdir2(join14(contents, "MacOS"), { recursive: true });
     await mkdir2(resources, { recursive: true });
@@ -20455,7 +20636,7 @@ class Helper {
     await writeFile2(scriptFile, script, { mode: 493 });
     await copyFile3(spec.stub, stub);
     await chmod(stub, 493);
-    if (!existsSync16(join14(resources, "AppIcon.icns")))
+    if (!existsSync17(join14(resources, "AppIcon.icns")))
       await this.drawIcon(resources);
     await this.run(["xattr", "-cr", spec.dir]);
     if (!await this.run(["codesign", "--force", "--deep", "-s", "-", spec.dir])) {
@@ -20470,8 +20651,8 @@ class Helper {
     const set = join14(tmp, "AppIcon.iconset");
     await mkdir2(set, { recursive: true });
     await this.run(["qlmanage", "-t", "-s", "1024", "-o", tmp, svg]);
-    const big = join14(tmp, `${basename4(svg)}.png`);
-    if (existsSync16(big)) {
+    const big = join14(tmp, `${basename5(svg)}.png`);
+    if (existsSync17(big)) {
       for (const size of [16, 32, 64, 128, 256, 512, 1024]) {
         await this.run(["sips", "-z", String(size), String(size), big, "--out", join14(set, `icon_${size}x${size}.png`)]);
       }
@@ -20914,7 +21095,7 @@ class SelfWatch {
 
 // ../daemon/src/core/state.ts
 import { randomBytes as randomBytes6 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync12, renameSync as renameSync3, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12, renameSync as renameSync3, writeFileSync as writeFileSync8 } from "fs";
 var TRUSTED_MAX = 16;
 var DAEMON_GROUPS = "daemon";
 var GROUPS_SAVE_MS = 250;
@@ -20923,7 +21104,7 @@ var empty = { repos: [], worktrees: [], sessions: {} };
 function loadState(paths) {
   ensureDirs(paths);
   const STATE_FILE = paths.stateFile;
-  if (!existsSync17(STATE_FILE))
+  if (!existsSync18(STATE_FILE))
     return structuredClone(empty);
   let raw;
   try {
@@ -20975,7 +21156,7 @@ function saveState(paths, state) {
 function loadOrCreateToken(paths) {
   ensureDirs(paths);
   const TOKEN_FILE = paths.tokenFile;
-  if (existsSync17(TOKEN_FILE))
+  if (existsSync18(TOKEN_FILE))
     return readFileSync12(TOKEN_FILE, "utf8").trim();
   const token = randomBytes6(32).toString("hex");
   writeFileSync8(TOKEN_FILE, token, { mode: 384 });
@@ -21063,9 +21244,9 @@ class StateStore {
     this.state.worktrees.push(wt);
     this.save();
   }
-  removeWorktree(id) {
+  removeWorktree(id, opts = {}) {
     const wt = this.state.worktrees.find((w) => w.id === id);
-    const repo = wt && wt.kind !== "spare" ? this.repo(wt.repoId) : undefined;
+    const repo = wt && wt.kind !== "spare" && !opts.refused ? this.repo(wt.repoId) : undefined;
     if (wt && repo)
       repo.promptedAt = Math.max(repo.promptedAt ?? 0, sentAt(wt));
     this.state.worktrees = this.state.worktrees.filter((w) => w.id !== id);
@@ -22010,7 +22191,7 @@ async function loadProjectTypescript(root) {
 }
 
 // ../daemon/src/drafts/store.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13, renameSync as renameSync4, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync13, renameSync as renameSync4, writeFileSync as writeFileSync9 } from "fs";
 var SAVE_DELAY_MS = 1000;
 
 class DraftStore {
@@ -22147,7 +22328,7 @@ class DraftStore {
   }
 }
 function readRecord(file) {
-  if (!existsSync18(file))
+  if (!existsSync19(file))
     return [];
   try {
     const raw = JSON.parse(readFileSync13(file, "utf8"));
@@ -22404,10 +22585,10 @@ class ExecService {
 
 // ../daemon/src/files/open.ts
 import { stat as stat3 } from "fs/promises";
-import { basename as basename5, resolve as resolve7 } from "path";
+import { basename as basename6, resolve as resolve7 } from "path";
 
 // ../daemon/src/repos/browse.ts
-import { existsSync as existsSync19, statSync as statSync6 } from "fs";
+import { existsSync as existsSync20, statSync as statSync6 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname6, join as join16 } from "path";
@@ -22424,7 +22605,7 @@ function holdsNothing(names) {
 }
 async function describeFolder(abs) {
   const path = collapseTilde(abs);
-  if (existsSync19(join16(abs, ".git")))
+  if (existsSync20(join16(abs, ".git")))
     return { path, kind: "project" };
   try {
     return { path, kind: holdsNothing(await readdir(abs)) ? "empty" : "folder" };
@@ -22439,10 +22620,10 @@ function describe2(typed, parent) {
     isDir = statSync6(typed).isDirectory();
   } catch {}
   return {
-    exists: existsSync19(typed),
+    exists: existsSync20(typed),
     isDir,
-    isRepo: isDir && existsSync19(join16(typed, ".git")),
-    parentExists: existsSync19(parent)
+    isRepo: isDir && existsSync20(join16(typed, ".git")),
+    parentExists: existsSync20(parent)
   };
 }
 async function browsePath(raw) {
@@ -22467,7 +22648,7 @@ async function browsePath(raw) {
     if (!name.toLowerCase().startsWith(prefix))
       continue;
     const abs = join16(dir, name);
-    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync19(join16(abs, ".git")) });
+    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync20(join16(abs, ".git")) });
   }
   entries.sort((a, b) => a.isRepo !== b.isRepo ? a.isRepo ? -1 : 1 : a.name.localeCompare(b.name));
   return { entries: entries.slice(0, MAX_ENTRIES), target };
@@ -23291,6 +23472,9 @@ class OpenService {
       throw new UserError(`${raw} is a folder: Toyon opens files`);
     return this.openFile(raw, path, st);
   }
+  async where(raw) {
+    return (await this.locate(raw)).path;
+  }
   async locate(raw) {
     const path = canonical(resolve7(expandTilde(raw)));
     const st = await stat3(path).catch((e) => {
@@ -23313,7 +23497,7 @@ class OpenService {
     return hit ? { kind: "file", worktreeId: hit.id, path: path.slice(hit.root.length + 1) } : null;
   }
   async grant(path, size, mtimeMs) {
-    const name = basename5(path);
+    const name = basename6(path);
     if (this.d.refused.some((r) => within2(path, canonical(resolve7(r))))) {
       throw new UserError(`${name} is inside Toyon's own folder, which is not for editing`);
     }
@@ -23390,13 +23574,70 @@ function parseAllowed(json) {
     return null;
   }
 }
-var PR_VIEW_FIELDS = "number,url,title,state,mergedAt,reviewDecision,statusCheckRollup,mergeable,autoMergeRequest";
+var PR_VIEW_FIELDS = "number,url,title,state,mergedAt,reviewDecision,statusCheckRollup,mergeable,autoMergeRequest,headRefOid";
 async function viewPr(repoPath, number) {
   const r = await gh(["pr", "view", String(number), "--json", PR_VIEW_FIELDS], repoPath, 20000);
   if (!r.ok || !r.out)
     return null;
   const parsed = parsePrView(r.out);
-  return parsed ? { ...parsed, at: Date.now() } : null;
+  if (!parsed)
+    return null;
+  if (parsed.state === "open" && !parsed.preview) {
+    const head = headOf(r.out);
+    const preview = head ? await viewDeploymentPreview(repoPath, head) : null;
+    if (preview)
+      parsed.preview = preview;
+  }
+  return { ...parsed, at: Date.now() };
+}
+function headOf(json) {
+  try {
+    const o = JSON.parse(json);
+    return typeof o.headRefOid === "string" && o.headRefOid ? o.headRefOid : null;
+  } catch {
+    return null;
+  }
+}
+var DEPLOYMENTS_QUERY = `query($owner: String!, $name: String!, $oid: GitObjectID!) {
+  repository(owner: $owner, name: $name) {
+    object(oid: $oid) { ... on Commit {
+      deployments(last: 10) { nodes { environment latestStatus { state environmentUrl } } }
+    } }
+  }
+}`;
+async function viewDeploymentPreview(repoPath, head) {
+  const r = await gh([
+    "api",
+    "graphql",
+    "-F",
+    "owner={owner}",
+    "-F",
+    "name={repo}",
+    "-f",
+    `oid=${head}`,
+    "-f",
+    `query=${DEPLOYMENTS_QUERY}`
+  ], repoPath, 20000);
+  if (!r.ok || !r.out)
+    return null;
+  return parseDeployments(r.out);
+}
+function parseDeployments(json) {
+  let nodes;
+  try {
+    const o = JSON.parse(json);
+    nodes = o.data?.repository?.object?.deployments?.nodes;
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(nodes))
+    return null;
+  for (const d of [...nodes].reverse()) {
+    const st = d?.latestStatus;
+    if (st?.state === "SUCCESS" && isPreviewUrl(st.environmentUrl))
+      return st.environmentUrl;
+  }
+  return null;
 }
 function parsePrView(json) {
   let o;
@@ -23412,6 +23653,7 @@ function parsePrView(json) {
   const checks = foldChecks(o.statusCheckRollup);
   const mergeable = o.mergeable === "MERGEABLE" ? true : o.mergeable === "CONFLICTING" ? false : undefined;
   const automerge = o.autoMergeRequest !== null && o.autoMergeRequest !== undefined;
+  const preview = state === "open" ? previewOf3(o.statusCheckRollup) : undefined;
   return {
     number: o.number,
     url: o.url,
@@ -23420,9 +23662,37 @@ function parsePrView(json) {
     ...review ? { review } : {},
     ...checks ? { checks } : {},
     ...mergeable !== undefined ? { mergeable } : {},
-    ...automerge ? { automerge } : {}
+    ...automerge ? { automerge } : {},
+    ...preview ? { preview } : {}
   };
 }
+function previewOf3(rollup) {
+  if (!Array.isArray(rollup))
+    return;
+  for (const c of rollup) {
+    const name = String(c.context ?? c.name ?? "");
+    if (!/preview/i.test(name))
+      continue;
+    const word = String(c.conclusion ?? c.state ?? "").toUpperCase();
+    if (word !== "SUCCESS")
+      continue;
+    const url = c.targetUrl ?? c.detailsUrl;
+    if (isPreviewUrl(url))
+      return url;
+  }
+  return;
+}
+function isPreviewUrl(url) {
+  if (typeof url !== "string")
+    return false;
+  let host;
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  return host !== "github.com" && !host.endsWith(".github.com");
+}
 function foldChecks(rollup) {
   if (!Array.isArray(rollup) || rollup.length === 0)
     return;
@@ -23447,7 +23717,6 @@ function prNumberOf(url) {
 
 // ../daemon/src/preview/errors.ts
 var KEPT = 5;
-var ROWS_MAX = 3;
 var TWICE_MS = 1000;
 
 class PageErrorService {
@@ -23455,75 +23724,35 @@ class PageErrorService {
   held = new Map;
   constructor(d) {
     this.d = d;
-    d.hub.on("agent", (worktreeId, _seq, event) => this.heard(worktreeId, event));
     d.hub.on("worktreesChanged", () => {
       for (const id of this.held.keys())
         if (!d.known(id))
           this.held.delete(id);
     });
   }
-  of(worktreeId) {
-    let h = this.held.get(worktreeId);
-    if (!h) {
-      h = { recent: [], running: false, noted: new Set, rows: 0 };
-      this.held.set(worktreeId, h);
-    }
-    return h;
-  }
-  heard(worktreeId, event) {
-    const h = this.of(worktreeId);
-    switch (event.type) {
-      case "user-message":
-      case "fix-asked":
-        h.noted = new Set;
-        h.rows = 0;
-        break;
-      case "turn-start":
-        h.running = true;
-        break;
-      case "turn-end":
-      case "agent-error":
-      case "agent-auth-required":
-        h.running = false;
-        this.flush(worktreeId, h, event.ts);
-        break;
-    }
-  }
   report(worktreeId, message) {
     if (!this.d.known(worktreeId)) {
       log.debug("pages", `an error from unknown worktree ${worktreeId} was dropped`);
       return;
     }
-    const h = this.of(worktreeId);
+    let h = this.held.get(worktreeId);
+    if (!h) {
+      h = [];
+      this.held.set(worktreeId, h);
+    }
     const now = this.d.now?.() ?? Date.now();
-    const last = h.recent.at(-1);
+    const last = h.at(-1);
     if (last && last.message === message && now - last.ts < TWICE_MS)
       return;
-    h.recent.push({ message, ts: now });
-    if (h.recent.length > KEPT)
-      h.recent.splice(0, h.recent.length - KEPT);
-    if (!h.running)
-      this.flush(worktreeId, h, now);
-  }
-  flush(worktreeId, h, ts) {
-    const fresh = [...new Set(h.recent.map((e) => e.message))].filter((m) => !h.noted.has(m));
-    if (fresh.length === 0 || h.rows >= ROWS_MAX)
-      return;
-    const agent = this.d.runtime.agentFor(worktreeId);
-    if (!agent)
-      return;
-    for (const m of fresh)
-      h.noted.add(m);
-    h.rows++;
-    agent.note({ type: "page-error", errors: fresh, ts });
+    h.push({ message, ts: now });
+    if (h.length > KEPT)
+      h.splice(0, h.length - KEPT);
   }
   loaded(worktreeId) {
-    const h = this.held.get(worktreeId);
-    if (h)
-      h.recent = [];
+    this.held.delete(worktreeId);
   }
   recent(worktreeId) {
-    return this.held.get(worktreeId)?.recent.map((e) => e.message) ?? [];
+    return this.held.get(worktreeId)?.map((e) => e.message) ?? [];
   }
   ambient(worktreeId) {
     const errors = this.recent(worktreeId);
@@ -23535,122 +23764,6 @@ ${errors.map((e) => `- ${e}`).join(`
   }
 }
 
-// ../daemon/src/preview/render.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var WAIT_MS2 = 1e4;
-var PATH_MAX = 2048;
-var refused = (text) => ({ text, isError: true });
-
-class RenderService {
-  d;
-  courier = () => false;
-  pending = new Map;
-  out = new Set;
-  constructor(d) {
-    this.d = d;
-  }
-  tool() {
-    return {
-      name: PREVIEW_TOOL,
-      description: "See whether a page of this worktree's preview renders without throwing. Pass `path` (for example `/about`): a browser the user has open loads it beside what they are looking at and reports the uncaught errors and unhandled rejections it threw in the moment after load. With no path, reports what the preview has thrown since it last loaded, without rendering. It does not describe what the page looks like, and it is not a substitute for the user's own checks.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "the route to render, starting with `/`; absent to report without rendering"
-          }
-        },
-        additionalProperties: false
-      }
-    };
-  }
-  async call(worktreeId, args) {
-    const a = args && typeof args === "object" && !Array.isArray(args) ? args : {};
-    if (a.path !== undefined && typeof a.path !== "string")
-      return refused("`path` is a string: a route, like `/about`.");
-    const path = a.path?.trim();
-    if (path !== undefined && (!/^(?:\/(?![/\\])|[?#])/.test(path) || path.length > PATH_MAX)) {
-      return refused("`path` is a route of the preview, starting with `/`, like `/about`.");
-    }
-    const standing = this.d.runtime.previewStanding(worktreeId);
-    if (!standing)
-      return refused("This project has nothing to run, so there is no page to render.");
-    if (standing.status !== "running")
-      return refused(previewContext(standing) ?? "The preview is not running.");
-    if (path === undefined)
-      return { text: this.held(worktreeId) };
-    if (this.out.has(worktreeId))
-      return refused("A render is already under way; call again when it has returned.");
-    const result = await this.render(worktreeId, path);
-    if (!result)
-      return refused(`No browser has this worktree open right now, so nothing can render it. ${this.held(worktreeId)}`);
-    if (!result.ok)
-      return refused(`Could not render ${path}: ${result.reason ?? "the page did not report"}.`);
-    return { text: this.report(path, result) };
-  }
-  render(worktreeId, path) {
-    const id = randomUUID2();
-    return new Promise((resolve) => {
-      const wait = this.d.waitMs ?? WAIT_MS2;
-      const timer = setTimeout(() => settle({
-        worktreeId,
-        id,
-        ok: false,
-        reason: `the page did not report within ${Math.round(wait / 1000)}s`,
-        errors: []
-      }), wait);
-      const settle = (r) => {
-        if (!this.pending.delete(id))
-          return;
-        clearTimeout(timer);
-        this.out.delete(worktreeId);
-        resolve(r);
-      };
-      this.pending.set(id, { worktreeId, settle });
-      this.out.add(worktreeId);
-      if (!this.courier(worktreeId, { t: "render", worktreeId, id, path }))
-        settle(null);
-    });
-  }
-  rendered(msg) {
-    const p = this.pending.get(msg.id);
-    if (!p || p.worktreeId !== msg.worktreeId) {
-      log.debug("render", `an answer for no render out on ${msg.worktreeId} was dropped`);
-      return;
-    }
-    p.settle(msg);
-  }
-  held(worktreeId) {
-    const errors = this.d.pageErrors.recent(worktreeId);
-    if (errors.length === 0)
-      return "The preview has thrown nothing since it last loaded.";
-    return `The preview has thrown since it last loaded:
-${errors.map((e) => `- ${e}`).join(`
-`)}`;
-  }
-  report(path, r) {
-    const title = r.title ? ` (title "${r.title}")` : "";
-    const landed = r.url ? pathOf(r.url) : null;
-    const elsewhere = landed && landed !== path ? ` It landed on ${landed}.` : "";
-    const head = `Rendered ${path} in the user's browser${title}.${elsewhere}`;
-    if (r.errors.length === 0)
-      return `${head} No errors in the moment after load.`;
-    const n = r.errors.length;
-    return `${head} ${n} ${n === 1 ? "error" : "errors"} in the moment after load:
-${r.errors.map((e) => `- ${e}`).join(`
-`)}`;
-  }
-}
-function pathOf(url) {
-  try {
-    const u = new URL(url);
-    return `${u.pathname}${u.search}`;
-  } catch {
-    return null;
-  }
-}
-
 // ../daemon/src/runtime/setup.ts
 var SETUP_RING = 64 * 1024;
 var SETUP_COLS = 120;
@@ -23779,9 +23892,9 @@ class AfterLand {
 }
 
 // ../daemon/src/repos/registry.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync7, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync7, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir10 } from "os";
-import { basename as basename7, dirname as dirname8, join as join21 } from "path";
+import { basename as basename8, dirname as dirname8, join as join21 } from "path";
 
 // ../daemon/src/git/base.ts
 async function resolveBase(repoPath, defaultBranch, route) {
@@ -23792,7 +23905,7 @@ async function resolveBase(repoPath, defaultBranch, route) {
 }
 
 // ../daemon/src/repos/config.ts
-import { closeSync, existsSync as existsSync20, openSync as openSync2, readdirSync as readdirSync7, readFileSync as readFileSync14, readSync, statSync as statSync7 } from "fs";
+import { closeSync, existsSync as existsSync21, openSync as openSync2, readdirSync as readdirSync7, readFileSync as readFileSync14, readSync, statSync as statSync7 } 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
@@ -25157,7 +25270,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) => existsSync20(join18(repoPath, rel)));
+var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync21(join18(repoPath, rel)));
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function parseSettings(text) {
   const errors = [];
@@ -25242,7 +25355,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 || !existsSync20(abs))
+  if (!abs || !existsSync21(abs))
     return config;
   let shared;
   try {
@@ -25290,7 +25403,7 @@ function detectConfig(repoPath) {
   if (explicit)
     log.warn("config", `${repoPath}: ${explicit.reason}; detecting instead`);
   const pkgPath = join18(repoPath, "package.json");
-  if (existsSync20(pkgPath)) {
+  if (existsSync21(pkgPath)) {
     const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
     const runner = detectRunner(repoPath, pkg.packageManager);
@@ -25312,7 +25425,7 @@ function detectConfig(repoPath) {
       };
     }
   }
-  if (existsSync20(join18(repoPath, "start.sh"))) {
+  if (existsSync21(join18(repoPath, "start.sh"))) {
     return { config: { run: { app: "./start.sh" } }, needsSetup: true, from: "start.sh" };
   }
   const assumed = assumeNothingToRun(repoPath);
@@ -25355,7 +25468,7 @@ function assumeNothingToRun(repoPath) {
   return marker && !servesPage(repoPath) ? marker : undefined;
 }
 function markerIn(repoPath) {
-  const named = NO_PAGE_MARKERS.find((f) => existsSync20(join18(repoPath, f)));
+  const named = NO_PAGE_MARKERS.find((f) => existsSync21(join18(repoPath, f)));
   if (named)
     return named;
   let entries;
@@ -25367,7 +25480,7 @@ function markerIn(repoPath) {
   return entries.find((f) => NO_PAGE_EXTENSIONS.some((ext) => f.endsWith(ext)));
 }
 function servesPage(repoPath) {
-  if (WEB_FILES.some((f) => existsSync20(join18(repoPath, f))))
+  if (WEB_FILES.some((f) => existsSync21(join18(repoPath, f))))
     return true;
   if (/^web:/m.test(head(join18(repoPath, "Procfile"))))
     return true;
@@ -25404,7 +25517,7 @@ function mentions(text, name) {
   return new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i").test(text);
 }
 function head(path) {
-  if (!existsSync20(path))
+  if (!existsSync21(path))
     return "";
   try {
     const fd = openSync2(path, "r");
@@ -25445,7 +25558,7 @@ function isLocalDatabase(url) {
 }
 function detectServices(repoPath) {
   const out = {};
-  const compose = COMPOSE_FILES.find((f) => existsSync20(join18(repoPath, f)));
+  const compose = COMPOSE_FILES.find((f) => existsSync21(join18(repoPath, f)));
   if (compose)
     out.compose = compose;
   for (const file of ENV_FILES) {
@@ -25484,21 +25597,21 @@ function inferPaths(cmd, repoPath, depth = 1) {
     const t = tokens[i];
     if (t === "cd") {
       const dir = tokens[i + 1];
-      if (dir && !dir.startsWith("-") && existsSync20(join18(repoPath, dir)))
+      if (dir && !dir.startsWith("-") && existsSync21(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] && existsSync20(join18(repoPath, mod[1]))) {
+    if (mod?.[1] && existsSync21(join18(repoPath, mod[1]))) {
       add(mod[1]);
       continue;
     }
     const rel = t.replace(/^\.\//, "");
     if (rel.startsWith("/") || rel.startsWith("..") || rel.includes("="))
       continue;
-    if (!existsSync20(join18(repoPath, rel)))
+    if (!existsSync21(join18(repoPath, rel)))
       continue;
     add(rel);
     if (depth > 0 && rel.endsWith(".sh")) {
@@ -25525,9 +25638,9 @@ function procCommand(runner, script, body) {
   return `${base}${runner === "npm" ? " --" : ""} ${flag}`;
 }
 function detectPages(repoPath, scripts, runner) {
-  if (!scripts.build || !existsSync20(join18(repoPath, "functions")))
+  if (!scripts.build || !existsSync21(join18(repoPath, "functions")))
     return null;
-  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join18(repoPath, f)).find((f) => existsSync20(f));
+  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join18(repoPath, f)).find((f) => existsSync21(f));
   if (!cfg)
     return null;
   const out = readFileSync14(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
@@ -25536,17 +25649,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 (existsSync20(join18(repoPath, "bun.lock")) || existsSync20(join18(repoPath, "bun.lockb")))
+  if (existsSync21(join18(repoPath, "bun.lock")) || existsSync21(join18(repoPath, "bun.lockb")))
     return "bun";
-  if (existsSync20(join18(repoPath, "pnpm-lock.yaml")))
+  if (existsSync21(join18(repoPath, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync20(join18(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
+  if (existsSync21(join18(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
     return "yarn";
   return "npm";
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync21, realpathSync as realpathSync2, statSync as statSync8 } from "fs";
+import { existsSync as existsSync22, realpathSync as realpathSync2, statSync as statSync8 } 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";
@@ -25561,13 +25674,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 (existsSync21(dir))
+  if (existsSync22(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) || existsSync21(typed) || !existsSync21(home))
+  if (typed !== join19(home, PROJECTS_FOLDER) || existsSync22(typed) || !existsSync22(home))
     return null;
   return join19(realpathSync2(home), PROJECTS_FOLDER);
 }
@@ -25577,10 +25690,10 @@ function planInPlace(opts) {
     throw new UserError(`${opts.name} is not a folder name`);
   }
   const typed = join19(resolveParent(opts.parent), name);
-  if (!existsSync21(typed) || !statSync8(typed).isDirectory())
+  if (!existsSync22(typed) || !statSync8(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
-  if (existsSync21(join19(dir, ".git")))
+  if (existsSync22(join19(dir, ".git")))
     throw new UserError(`${dir} is already a project; open it instead`);
   return { parent: dirname7(dir), dir, makeParent: false };
 }
@@ -25588,7 +25701,7 @@ function resolveParent(raw) {
   const typed = expandTilde(raw.trim());
   if (!typed.startsWith("/"))
     throw new UserError(`${raw} is not a folder path`);
-  if (!existsSync21(typed))
+  if (!existsSync22(typed))
     throw new UserError(`${raw} does not exist; make it first`);
   if (!statSync8(typed).isDirectory())
     throw new UserError(`${raw} is not a folder`);
@@ -25705,8 +25818,8 @@ async function ok(p, what) {
 }
 
 // ../daemon/src/repos/watcher.ts
-import { existsSync as existsSync22, watch } from "fs";
-import { basename as basename6, join as join20 } from "path";
+import { existsSync as existsSync23, watch } from "fs";
+import { basename as basename7, join as join20 } from "path";
 function watchDefaultBranch(repoPath, branch, onMove) {
   const last = { local: null, upstream: null };
   const read = async () => {
@@ -25770,11 +25883,11 @@ function watchDefaultBranch(repoPath, branch, onMove) {
     let mid = null;
     const armInner = () => {
       inner?.close();
-      inner = existsSync22(mine) ? tryWatch(mine) : null;
+      inner = existsSync23(mine) ? tryWatch(mine) : null;
     };
     const armMid = () => {
       mid?.close();
-      mid = existsSync22(remotes) ? tryWatch(remotes, (_event, filename) => {
+      mid = existsSync23(remotes) ? tryWatch(remotes, (_event, filename) => {
         if (!filename || filename === remote.out)
           armInner();
         schedule();
@@ -25852,7 +25965,7 @@ function watchWorktreeDir(repoPath, onChange) {
 }
 function watchConfigFile(repoPath, onChange) {
   const atRoot = new Set([CONFIG_FILES.root.shared, CONFIG_FILES.root.local, CONFIG_DIR]);
-  const inDir = new Set([CONFIG_FILES.folder.shared, CONFIG_FILES.folder.local].map((rel) => basename6(rel)));
+  const inDir = new Set([CONFIG_FILES.folder.shared, CONFIG_FILES.folder.local].map((rel) => basename7(rel)));
   const dir = join20(repoPath, CONFIG_DIR);
   let timer = null;
   let outer = null;
@@ -25868,7 +25981,7 @@ function watchConfigFile(repoPath, onChange) {
   const armInner = () => {
     inner?.close();
     inner = null;
-    if (!existsSync22(dir))
+    if (!existsSync23(dir))
       return;
     try {
       inner = watch(dir, (_event, filename) => {
@@ -25922,7 +26035,7 @@ class RepoRegistry {
   }
   async boot() {
     const { state } = this.d;
-    const gone = state.worktrees.filter((wt) => !existsSync23(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
+    const gone = state.worktrees.filter((wt) => !existsSync24(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) {
@@ -25990,7 +26103,7 @@ class RepoRegistry {
       return `${repo.name} is set up now`;
     if (main.promptedAt || main.lastTurn)
       return `${repo.name} has a chat now`;
-    if (existsSync23(join21(repo.path, ".claude")))
+    if (existsSync24(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`;
@@ -26071,7 +26184,7 @@ class RepoRegistry {
   }
   async register(rawPath, made) {
     const path = expandTilde(rawPath);
-    if (!existsSync23(path))
+    if (!existsSync24(path))
       throw new UserError(`${path} does not exist`);
     if (!await isGitRepo(path))
       throw new UserError(`${path} is not a git repository`);
@@ -26085,7 +26198,7 @@ class RepoRegistry {
     const repo = {
       id: shortId(),
       path: root,
-      name: basename7(root),
+      name: basename8(root),
       defaultBranch: await defaultBranch(root),
       config: detected.config,
       configFile: configTarget(root, !!made),
@@ -26145,7 +26258,7 @@ class RepoRegistry {
       throw new UserError(current.reason);
     const was = configTarget(repo.path, !!repo.made);
     const rel = configSibling(was, kind);
-    const moved = rel !== was && existsSync23(join21(repo.path, was));
+    const moved = rel !== was && existsSync24(join21(repo.path, was));
     if (moved && !(kind === "local" && await isTracked(repo.path, was))) {
       try {
         rmSync4(join21(repo.path, was));
@@ -26261,7 +26374,7 @@ class RepoRegistry {
   }
   placeConfig(repo) {
     const rel = configTarget(repo.path, !!repo.made);
-    if (isLocalConfigFile(rel) && existsSync23(join21(repo.path, rel))) {
+    if (isLocalConfigFile(rel) && existsSync24(join21(repo.path, rel))) {
       fireAndForget(repo.id, excludeFromGit(repo.path, rel), "exclude local settings");
     }
     if (repo.configFile === rel)
@@ -27840,7 +27953,7 @@ function isAlive(pid) {
 }
 
 // ../daemon/src/runtime/bridge-script.ts
-import { existsSync as existsSync24, readFileSync as readFileSync15, statSync as statSync9 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync15, statSync as statSync9 } from "fs";
 var LEARNED_MAX = 8;
 
 class BridgeScript {
@@ -27870,7 +27983,7 @@ class BridgeScript {
     this.cache = null;
   }
   get() {
-    if (!existsSync24(this.path))
+    if (!existsSync25(this.path))
       return "// toyon bridge not built";
     const s = statSync9(this.path);
     const stamp = `${s.mtimeMs}:${s.size}`;
@@ -27903,7 +28016,7 @@ import { homedir as homedir12, hostname as hostname2 } from "os";
 import { randomBytes as randomBytes7 } from "crypto";
 
 // ../daemon/src/agent/config.ts
-import { existsSync as existsSync25, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join23 } from "path";
 function agentConfigFiles(spec, repoPath, home = homedir11()) {
@@ -27911,7 +28024,7 @@ function agentConfigFiles(spec, repoPath, home = homedir11()) {
     id,
     label,
     path,
-    exists: existsSync25(path)
+    exists: existsSync26(path)
   });
   if (spec.id === "claude") {
     return [
@@ -27943,7 +28056,7 @@ function describeAgentConfig(spec, repoPath, home = homedir11()) {
   return { agent: spec.id, files, servers };
 }
 function readJson(path) {
-  if (!existsSync25(path))
+  if (!existsSync26(path))
     return null;
   try {
     const v = JSON.parse(readFileSync16(path, "utf8"));
@@ -27964,7 +28077,7 @@ function serversOf(raw, scope) {
   });
 }
 function codexServers(path) {
-  if (!existsSync25(path))
+  if (!existsSync26(path))
     return [];
   const out = [];
   let current = null;
@@ -28597,12 +28710,6 @@ var handlers = {
   "page-loaded"(msg, _ctx, s) {
     s.pageErrors.loaded(msg.worktreeId);
   },
-  "fix-page"(msg, _ctx, s) {
-    s.fix.pressPage(msg.worktreeId);
-  },
-  rendered(msg, _ctx, s) {
-    s.render.rendered(msg);
-  },
   async chat(msg, ctx, s) {
     await sending(s, ctx, msg, msg.attachments, () => s.worktrees.send(msg.worktreeId, {
       text: msg.text,
@@ -28859,6 +28966,15 @@ var handlers = {
   reveal(msg, _ctx, s) {
     s.files.reveal(msg.worktreeId, msg.path);
   },
+  async "reveal-path"(msg, _ctx, s) {
+    s.files.revealPath(await s.opens.where(msg.path));
+  },
+  async "reveal-attachment"(msg, _ctx, s) {
+    const path = await s.attachments.locate(msg.worktreeId, msg.file, (file) => s.worktrees.archivedAttachment(msg.worktreeId, file));
+    if (!path)
+      throw new UserError("that attachment is no longer on this machine");
+    s.files.revealPath(path);
+  },
   async "discard-files"(msg, _ctx, s) {
     try {
       for (const path of msg.paths)
@@ -29015,9 +29131,12 @@ var handlers = {
     s.files.revealPath(file.path);
   },
   async "agent-logout"(msg, _ctx, s) {
-    await s.accounts.logout(msg.agent);
+    await s.readiness.logout(msg.agent);
     s.hub.emit("agentsChanged");
   },
+  "agent-check"(msg, _ctx, s) {
+    fireAndForget("agents", s.readiness.check(msg.agent), "agent check");
+  },
   "set-default-agent"(msg, _ctx, s) {
     s.agents.require(msg.agent);
     s.state.setDefaultAgent(msg.agent);
@@ -29140,7 +29259,7 @@ async function dispatch(msg, ctx, s) {
 }
 
 // ../daemon/src/server/http.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import { hostname } from "os";
 import { join as join24 } from "path";
 
@@ -29365,6 +29484,20 @@ function createFetch(opts) {
       const refused = await opts.restart(url.searchParams.has(RESTART_NOW));
       return refused ? new Response(refused, { status: 409 }) : new Response(null, { status: 202 });
     }
+    if (url.pathname === "/changelog" && req.method === "GET") {
+      if (!authed(req))
+        return unauthorized();
+      const text = await opts.changelog();
+      if (text === null)
+        return new Response("this copy of Toyon carries no release notes", { status: 404 });
+      return new Response(text, {
+        headers: {
+          "content-type": "text/markdown; charset=utf-8",
+          "cache-control": NO_STORE2,
+          "x-content-type-options": "nosniff"
+        }
+      });
+    }
     const paired = await opts.pairing(req, url, d);
     if (paired)
       return paired;
@@ -29431,7 +29564,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 || !existsSync26(path))
+      if (!path || !existsSync27(path))
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), {
         headers: { "cache-control": IMMUTABLE, ...attachedHeaders(opts.attachments.uploads.imageType(id)) }
@@ -29444,9 +29577,14 @@ 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 && existsSync26(p));
+      const path = places.find((p) => !!p && existsSync27(p));
       if (!path)
         return new Response("not found", { status: 404 });
+      if (url.searchParams.has("where")) {
+        return new Response(path, {
+          headers: { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" }
+        });
+      }
       return new Response(Bun.file(path), {
         headers: { "cache-control": IMMUTABLE, ...attachedHeaders(drawnType(file ?? "")) }
       });
@@ -29479,7 +29617,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 (existsSync26(file) && Bun.file(file).size > 0) {
+    if (existsSync27(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 };
@@ -29499,7 +29637,7 @@ function createFetch(opts) {
     if (hashed)
       return new Response("not found", { status: 404 });
     const index = join24(opts.shellDist, "index.html");
-    if (existsSync26(index))
+    if (existsSync27(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 });
   }
@@ -29574,14 +29712,6 @@ function startServer(opts) {
     }
   };
   const send = (ws, msg) => raw(ws, JSON.stringify(msg));
-  s.render.courier = (worktreeId, msg) => {
-    const shells = [...sockets].filter((ws) => ws.data.authed && !ws.data.preview);
-    const ws = shells.find((w) => w.data.view === worktreeId) ?? shells.find((w) => w.data.subs.has(worktreeId));
-    if (!ws)
-      return false;
-    send(ws, msg);
-    return true;
-  };
   const broadcast = (msg) => {
     const json = JSON.stringify(msg);
     for (const ws of sockets)
@@ -29759,20 +29889,9 @@ function startServer(opts) {
   };
   s.hub.on("themesChanged", themesChanged);
   themesChanged();
-  const agentInfos = () => s.accounts.describe(s.agents.infos()).map((a) => {
-    const models = s.state.cachedOptions(a.id, "model");
-    const efforts = s.state.cachedOptions(a.id, "thought_level");
-    const spec = s.agents.get(a.id);
-    return {
-      ...a,
-      ...models.length > 0 ? { models } : {},
-      ...efforts.length > 0 ? { efforts } : {},
-      ...spec && !lacksQuickModel(spec, s.state) ? { quick: true } : {}
-    };
-  });
   const agentsMsg = () => ({
     t: "agents",
-    agents: agentInfos(),
+    agents: s.readiness.describe(),
     defaultAgent: s.agents.defaultId(s.state.defaultAgent),
     agentChosen: s.state.defaultAgent !== undefined
   });
@@ -29810,7 +29929,7 @@ function startServer(opts) {
       trunks,
       themes: s.themes.themes,
       themePrefs: s.themes.prefs,
-      agents: agentInfos(),
+      agents: s.readiness.describe(),
       defaultAgent: s.agents.defaultId(s.state.defaultAgent),
       agentChosen: s.state.defaultAgent !== undefined,
       home: homedir12(),
@@ -29880,7 +29999,8 @@ function startServer(opts) {
       restartWait: () => ({ waiting: s.restarter.waitingOn(), asking: s.restarter.asking() }),
       grants: opts.grants,
       trusted: () => s.state.trustedOrigins,
-      mcp: (req, id) => s.mcp.fetch(req, id)
+      mcp: (req, id) => s.mcp.fetch(req, id),
+      changelog: () => Bun.file(opts.changelog).text().catch(() => null)
     }),
     websocket: {
       async open(ws) {
@@ -29897,6 +30017,7 @@ function startServer(opts) {
         sockets.add(ws);
         link(ws);
         send(ws, await helloFrame());
+        fireAndForget("agents", s.agents.retryFailed(), "agent install retry");
         for (const o of s.opens.takePending())
           send(ws, openedFrame(o));
       },
@@ -29991,9 +30112,9 @@ function startServer(opts) {
 }
 
 // ../daemon/src/themes/store.ts
-import { existsSync as existsSync27, readdirSync as readdirSync8, readFileSync as readFileSync17, statSync as statSync10, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync28, readdirSync as readdirSync8, readFileSync as readFileSync17, statSync as statSync10, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir13 } from "os";
-import { basename as basename8, dirname as dirname9, join as join25, resolve as resolve9 } from "path";
+import { basename as basename9, dirname as dirname9, join as join25, resolve as resolve9 } from "path";
 var home = homedir13();
 var defaultExtensionDirs = [
   join25(home, ".vscode", "extensions"),
@@ -30078,7 +30199,7 @@ class ThemeStore {
     if (json && typeof json === "object" && typeof json.include === "string") {
       throw new ThemeImportError("this theme file uses `include`; drop the whole extension folder's theme into ~/.toyon/themes or install it in VS Code and rescan");
     }
-    const base = slug(basename8(name).replace(/\.(json|jsonc)$/i, ""));
+    const base = slug(basename9(name).replace(/\.(json|jsonc)$/i, ""));
     const theme = vscodeToTheme(json, {
       id: `file:${base}`,
       name: json?.name ?? base,
@@ -30113,7 +30234,7 @@ function readVscodeTheme(file, depth = 0) {
   return t;
 }
 function loadDir(dir) {
-  if (!existsSync27(dir))
+  if (!existsSync28(dir))
     return [];
   const out = [];
   for (const f of readdirSync8(dir)) {
@@ -30135,7 +30256,7 @@ function loadDir(dir) {
   return out;
 }
 function discover(dir) {
-  if (!existsSync27(dir))
+  if (!existsSync28(dir))
     return [];
   const out = [];
   let entries;
@@ -30148,7 +30269,7 @@ function discover(dir) {
     const extDir = join25(dir, name);
     const pkgFile = join25(extDir, "package.json");
     try {
-      if (!statSync10(extDir).isDirectory() || !existsSync27(pkgFile))
+      if (!statSync10(extDir).isDirectory() || !existsSync28(pkgFile))
         continue;
       const pkg = JSON.parse(readFileSync17(pkgFile, "utf8"));
       const themes = pkg.contributes?.themes;
@@ -30157,7 +30278,7 @@ function discover(dir) {
       const ext = `${pkg.publisher ?? "local"}.${pkg.name ?? name}`;
       let nls = {};
       const nlsFile = join25(extDir, "package.nls.json");
-      if (existsSync27(nlsFile)) {
+      if (existsSync28(nlsFile)) {
         try {
           nls = JSON.parse(readFileSync17(nlsFile, "utf8"));
         } catch {}
@@ -30228,7 +30349,7 @@ var REFRESH_EVERY_MS = 60000;
 var CHECK_EVERY_MS = 6 * 60 * 60000;
 var FIRST_CHECK_MS = 2 * 60000;
 var SETTLED_MS = 2 * 60000;
-var RETRY_AFTER_MS = 24 * 60 * 60000;
+var RETRY_AFTER_MS2 = 24 * 60 * 60000;
 var INSTALL_SETTLE_MS = 60000;
 
 class UpdateService {
@@ -30380,7 +30501,7 @@ class UpdateService {
     if (this.needsInstall() && this.d.command(target) === null)
       return;
     const failed = this.d.state.updateFailed;
-    if (failed?.version === target && this.now() - failed.at < RETRY_AFTER_MS)
+    if (failed?.version === target && this.now() - failed.at < RETRY_AFTER_MS2)
       return;
     if (this.d.busy()) {
       this.busyAt = this.now();
@@ -30571,7 +30692,7 @@ class BackendShare {
 
 // ../daemon/src/worktrees/cache.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync28, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync29, 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";
 
@@ -30604,7 +30725,7 @@ var STALE_MS = 30 * 24 * 3600000;
 var TMP = ".tmp-";
 var MANIFEST = "manifest.json";
 function defaultTools(dir) {
-  const has = (...files) => files.some((f) => existsSync28(join26(dir, f)));
+  const has = (...files) => files.some((f) => existsSync29(join26(dir, f)));
   const out = [];
   if (has("bun.lock", "bun.lockb"))
     out.push("bun --version");
@@ -30617,7 +30738,7 @@ function defaultTools(dir) {
   return out;
 }
 function withSidecars(root, rel) {
-  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync28(join26(root, n)));
+  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync29(join26(root, n)));
 }
 var entryName = (base, at) => `${base.slice(0, 12)}-${at.toString(36)}`;
 async function listEntries(familyDir) {
@@ -30633,7 +30754,7 @@ async function listEntries(familyDir) {
     if (!m?.[1] || !m[2])
       continue;
     const dir = join26(familyDir, name);
-    if (!existsSync28(join26(dir, MANIFEST)))
+    if (!existsSync29(join26(dir, MANIFEST)))
       continue;
     out.push({ dir, base: m[1], at: Number.parseInt(m[2], 36) });
   }
@@ -30671,7 +30792,7 @@ class ArtifactCache {
       }
       const restored = [];
       for (const rel of policy.paths) {
-        if (existsSync28(join26(wt.path, rel)))
+        if (existsSync29(join26(wt.path, rel)))
           continue;
         const names = withSidecars(entry.dir, rel);
         if (names.length === 0)
@@ -30712,7 +30833,7 @@ class ArtifactCache {
     let tmp;
     let slot;
     try {
-      const present = policy.paths.filter((rel) => existsSync28(join26(wt.path, rel)));
+      const present = policy.paths.filter((rel) => existsSync29(join26(wt.path, rel)));
       if (present.length === 0)
         return;
       const family = await this.family(wt, repo, policy);
@@ -30996,8 +31117,7 @@ var RESPONSE = {
   conflict: { does: "ask" },
   check: { does: "ask", once: true },
   command: { does: "offer" },
-  preview: { does: "offer" },
-  page: { does: "offer" }
+  preview: { does: "offer" }
 };
 function lastAsked(entries) {
   for (let i = entries.length - 1;i >= 0; i--) {
@@ -31015,7 +31135,7 @@ function askedFor(entries, toolId) {
 function lastStop(entries) {
   for (let i = entries.length - 1;i >= 0; i--) {
     const e = entries[i].event;
-    if (e.type === "usage" || e.type === "session-info" || e.type === "page-error")
+    if (e.type === "usage" || e.type === "session-info")
       continue;
     if (e.type === "turn-end" && e.stopReason === "interrupted")
       return { kind: "stopped" };
@@ -31025,21 +31145,6 @@ function lastStop(entries) {
   }
   return null;
 }
-function lastPageErrors(entries) {
-  const errors = [];
-  for (let i = entries.length - 1;i >= 0; i--) {
-    const e = entries[i].event;
-    if (e.type === "page-error") {
-      errors.unshift(...e.errors);
-      continue;
-    }
-    if (e.type === "user-message" || e.type === "fix-asked")
-      break;
-    if (e.type === "tool-start" && isEditTool({ name: e.name, kind: e.kind }))
-      break;
-  }
-  return errors;
-}
 function failureOf(entries, toolId) {
   let command;
   for (const { event } of entries) {
@@ -31104,17 +31209,6 @@ class FixService {
     if (!this.report(worktreeId, failure, { pressed: true }))
       throw new UserError("nothing runs on main");
   }
-  pressPage(worktreeId) {
-    this.d.state.requireWorktree(worktreeId);
-    const agent = this.d.runtime.agentFor(worktreeId);
-    if (!agent)
-      throw new UserError("worktree still starting; try again in a moment");
-    const errors = lastPageErrors(agent.transcript());
-    if (errors.length === 0)
-      throw new UserError("nothing the preview threw to fix");
-    if (!this.report(worktreeId, { kind: "page", errors }, { pressed: true }))
-      throw new UserError("nothing runs on main");
-  }
   goOn(worktreeId) {
     const wt = this.d.state.requireWorktree(worktreeId);
     if (isMain(wt))
@@ -31134,12 +31228,12 @@ class FixService {
 }
 
 // ../daemon/src/worktrees/handoff.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var MESSAGE_MAX = 20000;
 var TITLE_MAX2 = 200;
 var PROJECT_MAX = 200;
 var PER_TURN_MAX = 3;
-var refused2 = (text) => ({ text, isError: true });
+var refused = (text) => ({ text, isError: true });
 function openProposals(entries) {
   const open = new Map;
   for (const { event } of entries) {
@@ -31222,7 +31316,7 @@ class HandoffService {
     const a = args && typeof args === "object" && !Array.isArray(args) ? args : null;
     const shaped = a && typeof a.project === "string" && typeof a.message === "string" && (a.title === undefined || typeof a.title === "string");
     if (!shaped)
-      return refused2("handoff takes { project: string, message: string, title?: string }.");
+      return refused("handoff takes { project: string, message: string, title?: string }.");
     return this.propose(worktreeId, { project: a.project, message: a.message, ...a.title ? { title: a.title } : {} }, "agent");
   }
   propose(worktreeId, p, by) {
@@ -31230,31 +31324,31 @@ class HandoffService {
     if (!wt)
       throw new UserError("that chat is gone");
     if (p.project.length > PROJECT_MAX)
-      return refused2(`The project name is over ${PROJECT_MAX} characters.`);
+      return refused(`The project name is over ${PROJECT_MAX} characters.`);
     if ((p.title ?? "").length > TITLE_MAX2)
-      return refused2(`The title is over ${TITLE_MAX2} characters; a few words.`);
+      return refused(`The title is over ${TITLE_MAX2} characters; a few words.`);
     if (p.message.length > MESSAGE_MAX) {
-      return refused2(`The message is over ${MESSAGE_MAX} characters; cut it to what the other agent needs.`);
+      return refused(`The message is over ${MESSAGE_MAX} characters; cut it to what the other agent needs.`);
     }
     const target = this.resolve(worktreeId, p.project);
     if ("refused" in target)
-      return refused2(target.refused);
+      return refused(target.refused);
     const message = p.message.trim();
     if (!message)
-      return refused2("Write the message the other project's agent should start from.");
+      return refused("Write the message the other project's agent should start from.");
     const agent = this.d.runtime.ensureAgent(wt).agent;
     const entries = agent.transcript();
     if (openProposals(entries).length > 0) {
-      return refused2("A handoff is already waiting for the person on this chat; finish your turn.");
+      return refused("A handoff is already waiting for the person on this chat; finish your turn.");
     }
     if (by === "agent" && proposedThisTurn(entries) >= PER_TURN_MAX) {
-      return refused2("Three handoffs were proposed this turn already; finish your turn and let the person answer.");
+      return refused("Three handoffs were proposed this turn already; finish your turn and let the person answer.");
     }
     const title = p.title?.trim();
     const { repo } = target;
     agent.note({
       type: "handoff-proposed",
-      id: randomUUID3(),
+      id: randomUUID2(),
       repo: { id: repo.id, name: repo.name, path: repo.path },
       message,
       ...title ? { title } : {},
@@ -31370,6 +31464,7 @@ function match(repos, q) {
 // ../daemon/src/worktrees/landing.ts
 var TAIL_CHARS = 400;
 var DIFF_CHARS = 2000;
+var CONTEXT_CHARS2 = 800;
 var CHECK_SLOTS = 2;
 
 class LandingService {
@@ -31445,14 +31540,7 @@ class LandingService {
     const repo = this.d.state.requireRepo(wt.repoId);
     this.judging.set(worktreeId, turn.at);
     const started = Date.now();
-    const entries = this.d.transcript(worktreeId);
-    const prompt = landPrompt({
-      title: wt.title,
-      firstAsk: firstAskOf(entries),
-      turns: turnsSince(entries, 0),
-      diffStat: await diffSummary(wt.path, baseOf(repo)),
-      recentSubjects: await recentSubjects(wt.path, baseOf(repo))
-    });
+    const prompt = landPrompt(await this.landInput(wt, repo));
     let verdict = null;
     try {
       verdict = await this.d.judge(wt, prompt);
@@ -31525,6 +31613,25 @@ class LandingService {
       return;
     fireAndForget(worktreeId, this.run(wt, { at: Date.now(), ask: false, quiet: true }), "landing recheck");
   }
+  async landInput(wt, repo) {
+    const base = baseOf(repo);
+    const entries = this.d.transcript(wt.id);
+    const [diff, subjects, committedAt] = await Promise.all([
+      diffSummary(wt.id, wt.path, base),
+      recentSubjects(wt.path, base),
+      lastOwnCommitAt(wt.id, wt.path, base)
+    ]);
+    const since = Math.max(committedAt, wt.lands?.at(-1)?.at ?? 0);
+    return {
+      title: wt.title,
+      firstAsk: firstAskOf(entries),
+      turns: turnsSince(entries, since),
+      earlier: since > 0,
+      diffStat: diff.own,
+      committedStat: diff.committed,
+      recentSubjects: subjects
+    };
+  }
   async hasWork(wt) {
     const repo = this.d.state.requireRepo(wt.repoId);
     const files = await statusFiles(wt.path);
@@ -31547,14 +31654,14 @@ class LandingService {
     };
     this.judging.set(worktreeId, opts.at);
     const started = Date.now();
-    this.d.worktrees.setLanding(worktreeId, { at: opts.at, check: "pending", ready: false, fingerprint: "", ...kept });
+    const pending = { at: opts.at, check: "pending", ready: false, fingerprint: "", ...kept };
+    this.d.worktrees.setLanding(worktreeId, pending);
     const live = () => !this.stopping && this.judging.get(worktreeId) === opts.at && !!this.d.state.worktree(worktreeId);
-    let check = "none";
-    let checkTail;
-    let waited = 0;
-    let ran;
     const command = repo.config.check?.trim();
-    if (command) {
+    let checkDone = false;
+    const checked = async () => {
+      if (!command)
+        return { check: "none" };
       const ceiling = timeoutFor(repo.config, "check");
       this.d.runs.drop(worktreeId, "check");
       const run = this.d.runs.begin(worktreeId, "check", {
@@ -31563,9 +31670,11 @@ class LandingService {
       });
       if (!await run.admitted)
         return;
-      if (!live())
-        return run.finish(null);
-      waited = Date.now() - started;
+      if (!live()) {
+        run.finish(null);
+        return;
+      }
+      const waited = Date.now() - started;
       let r;
       try {
         r = await this.d.check(worktreeId, command, { quiet: opts.quiet, timeoutMs: ceiling, onSpawn: run.spawned });
@@ -31576,8 +31685,8 @@ class LandingService {
       run.finish(r.exit);
       if (!live())
         return;
-      ran = r;
-      check = r.exit === 0 ? "pass" : "fail";
+      const check = r.exit === 0 ? "pass" : "fail";
+      let checkTail;
       if (r.exit === "timeout") {
         checkTail = [`gave up after ${describeDuration(ceiling)}`, tail(r.text)].filter(Boolean).join(`
 `);
@@ -31585,19 +31694,14 @@ class LandingService {
         checkTail = tail(r.text) || `exit ${r.exit}`;
       else
         this.d.hub.emit("checkPassed", worktreeId);
-    }
-    let verdict = null;
-    let unanswered = false;
-    if (opts.ask && check !== "fail" && this.d.judge) {
-      const entries = this.d.transcript(worktreeId);
-      const prompt = landPrompt({
-        title: wt.title,
-        firstAsk: firstAskOf(entries),
-        turns: turnsSince(entries, 0),
-        diffStat: await diffSummary(wt.path, baseOf(repo)),
-        recentSubjects: await recentSubjects(wt.path, baseOf(repo)),
-        ...opts.note ? { note: opts.note } : {}
-      });
+      return { check, ran: r, waited, ...checkTail ? { checkTail } : {} };
+    };
+    const asked = async () => {
+      if (!opts.ask || !this.d.judge)
+        return { verdict: null, unanswered: false };
+      const prompt = landPrompt({ ...await this.landInput(wt, repo), ...opts.note ? { note: opts.note } : {} });
+      let verdict = null;
+      let unanswered = false;
       try {
         verdict = await this.d.judge(wt, prompt);
       } catch (e) {
@@ -31608,16 +31712,29 @@ class LandingService {
       }
       if (!live())
         return;
-    }
+      if (!checkDone && verdict) {
+        this.recapTurn(worktreeId, verdict);
+        this.d.worktrees.setLanding(worktreeId, { ...pending, ...messageOf(verdict) });
+      }
+      return { verdict, unanswered };
+    };
+    const [checkResult, askResult] = await Promise.all([
+      checked().finally(() => {
+        checkDone = true;
+      }),
+      asked()
+    ]);
+    if (!checkResult || !askResult || !live())
+      return;
+    const { check, checkTail, ran, waited = 0 } = checkResult;
+    const { verdict, unanswered } = askResult;
     const landing = {
       at: opts.at,
       check,
       ...checkTail ? { checkTail } : {},
       ready: check !== "fail",
       ...kept,
-      ...verdict && !verdict.ready && verdict.why ? { why: verdict.why } : {},
-      ...verdict?.subject ? { subject: verdict.subject } : {},
-      ...verdict?.body ? { body: verdict.body } : {},
+      ...verdict ? messageOf(verdict) : {},
       ...unanswered ? { unanswered: true } : {},
       fingerprint: await treeFingerprint(wt.path)
     };
@@ -31627,14 +31744,18 @@ class LandingService {
     if (!live())
       return;
     this.judging.delete(worktreeId);
-    const record = this.d.state.worktree(worktreeId)?.lastTurn;
-    if (record && verdict?.recap)
-      record.recap = { at: Date.now(), text: verdict.recap };
+    if (verdict)
+      this.recapTurn(worktreeId, verdict);
     log.info(worktreeId, `landing: check ${check}${landing.why ? ", doubted" : ""}${opts.ask ? "" : ", check only"}, ${Date.now() - started}ms${waited > 100 ? ` (waited ${waited}ms for a check slot)` : ""}`);
     this.d.worktrees.setLanding(worktreeId, landing);
     if (command && check === "fail" && ran && typeof ran.exit === "number" && !opts.quiet)
       this.d.hub.emit("checkFailed", worktreeId, { toolId: ran.toolId, command, text: ran.text });
   }
+  recapTurn(worktreeId, verdict) {
+    const record = this.d.state.worktree(worktreeId)?.lastTurn;
+    if (record && verdict.recap)
+      record.recap = { at: Date.now(), text: verdict.recap };
+  }
   async sharedMigration(wt, repo) {
     if (!repo.services || keepsCopiesApart(repo.config))
       return;
@@ -31644,31 +31765,44 @@ class LandingService {
     return "this changes migrations, and the worktrees share the database";
   }
 }
+function messageOf(verdict) {
+  return {
+    ...!verdict.ready && verdict.why ? { why: verdict.why } : {},
+    ...verdict.subject ? { subject: verdict.subject } : {},
+    ...verdict.body ? { body: verdict.body } : {}
+  };
+}
 function tail(text) {
   const t = text.replace(/\s+$/, "");
   return t.length > TAIL_CHARS ? t.slice(-TAIL_CHARS) : t;
 }
-async function diffSummary(path, defaultBr) {
+async function diffSummary(id, path, defaultBr) {
   const [base, dirty, untracked] = await Promise.all([
     git(path, "merge-base", "HEAD", defaultBr),
     git(path, "diff", "HEAD", "--stat"),
     git(path, "ls-files", "--others", "--exclude-standard")
   ]);
+  if (!base.ok)
+    log.warn(id, `landing question: no merge base with ${defaultBr}: ${base.err.trim()}`);
   const committed = base.ok && base.out ? await git(path, "diff", "--stat", base.out, "HEAD") : null;
-  const parts = [
-    committed?.out ? `Committed on the branch:
-${committed.out}` : "",
-    dirty.out ? `Uncommitted:
-${dirty.out}` : "",
-    untracked.out ? `New files:
-${untracked.out}` : ""
-  ].filter(Boolean);
-  const text = parts.join(`
+  const own = [dirty.out ? `Uncommitted:
+${dirty.out}` : "", untracked.out ? `New files:
+${untracked.out}` : ""].filter(Boolean).join(`
 
 `);
-  return text.length > DIFF_CHARS ? `${text.slice(0, DIFF_CHARS)}
+  return { own: cap(own, DIFF_CHARS), committed: cap(committed?.out ?? "", CONTEXT_CHARS2) };
+}
+function cap(text, max) {
+  return text.length > max ? `${text.slice(0, max)}
 ...` : text;
 }
+async function lastOwnCommitAt(id, path, defaultBr) {
+  const r = await git(path, "log", "-1", "--no-merges", "--format=%at", `${defaultBr}..HEAD`);
+  if (!r.ok)
+    log.warn(id, `landing question: could not read the branch's commits over ${defaultBr}: ${r.err.trim()}`);
+  const seconds = Number(r.out.trim());
+  return r.ok && Number.isFinite(seconds) ? seconds * 1000 : 0;
+}
 async function recentSubjects(path, defaultBr) {
   const r = await git(path, "log", "--format=%s", "-n", "5", defaultBr);
   return r.ok ? r.out.split(`
@@ -31787,7 +31921,7 @@ async function mergedBranches(repoPath, defaultBr) {
 
 // ../daemon/src/worktrees/discover.ts
 import { createHash as createHash5 } from "crypto";
-import { basename as basename9 } from "path";
+import { basename as basename10 } from "path";
 
 // ../daemon/src/git/worktrees.ts
 function parseWorktreeList(out) {
@@ -31876,7 +32010,7 @@ function subtractKnown(repoId, listed, known) {
     rows.push({
       id: discoveredId(g.path),
       repoId,
-      name: g.branch ?? basename9(g.path),
+      name: g.branch ?? basename10(g.path),
       path: g.path,
       ...g.branch ? { branch: g.branch } : {},
       ...g.locked ? { locked: true } : {},
@@ -32038,7 +32172,7 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { cpSync, existsSync as existsSync33, readFileSync as readFileSync20, rmSync as rmSync8 } from "fs";
+import { cpSync, existsSync as existsSync34, readFileSync as readFileSync20, rmSync as rmSync8 } from "fs";
 import { rm as rm5 } from "fs/promises";
 import { dirname as dirname12, join as join30 } from "path";
 
@@ -32164,7 +32298,7 @@ async function dropLandRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/git/land.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 var STEP_TIMEOUT_MS = 10 * 60000;
 function rowOf(r) {
   return r.shown && r.toolId && r.command ? { toolId: r.toolId, command: r.command, text: r.text } : undefined;
@@ -32174,7 +32308,7 @@ var UNWATCHED = {
   step() {},
   git: (cwd, args) => stepRun(cwd, args)
 };
-function refused3(what, r, n = 200) {
+function refused2(what, r, n = 200) {
   if (r.exit === "timeout") {
     const after = describeDuration(r.ceilingMs ?? STEP_TIMEOUT_MS);
     return `${what} gave up after ${after}${r.shown ? "; what it printed is on the chat" : ""}`;
@@ -32185,7 +32319,7 @@ function stepRefused(what, r, n = 200) {
   const row = typeof r.exit === "number" && r.hook ? rowOf(r) : undefined;
   return {
     ok: false,
-    message: refused3(what, r, n),
+    message: refused2(what, r, n),
     ...row && r.hook ? { hook: { ...row, name: r.hook } } : {}
   };
 }
@@ -32295,7 +32429,7 @@ async function midway(worktreePath) {
   if (!r.ok)
     return null;
   const at = r.out.split(`
-`).findIndex((file) => file && existsSync29(file));
+`).findIndex((file) => file && existsSync30(file));
   return MIDWAY[at]?.[1] ?? null;
 }
 async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = false) {
@@ -32403,17 +32537,41 @@ async function landLocally(worktreePath, branch, repoPath, defaultBr, method, me
   }
   return { ok: true, message: `merged ${branch} into ${defaultBr}` };
 }
-async function squashMessage(worktreePath, defaultBr, suggested) {
+async function squashMessage(worktreePath, defaultBr, suggested, typed = false) {
   const n = await git(worktreePath, "rev-list", "--count", `${defaultBr}..HEAD`);
   if (n.out === "1") {
+    if (typed && suggested)
+      return suggested;
     const one = await git(worktreePath, "log", "-1", "--format=%B");
     if (one.ok && one.out.trim())
       return one.out.trim();
   }
-  if (suggested)
-    return suggested;
-  const subjects = await git(worktreePath, "log", "--format=%s", `${defaultBr}..HEAD`);
-  return subjects.out.trim() || "land";
+  const log = await git(worktreePath, "log", "--reverse", "--no-merges", "--format=%s", `${defaultBr}..HEAD`);
+  const subjects = log.out.split(`
+`).filter(Boolean);
+  const [first = "", ...rest] = (suggested ?? subjects.at(-1) ?? "land").split(`
+`);
+  const subject = first.trim();
+  const others = subjects.at(-1) === subject ? subjects.slice(0, -1) : subjects;
+  const body = [
+    rest.join(`
+`).trim(),
+    others.length ? `Squashed with the branch's earlier commits:
+${others.join(`
+`)}` : ""
+  ].filter(Boolean).join(`
+
+`);
+  return body ? `${subject}
+
+${body}` : subject;
+}
+function splitMessage(text) {
+  const [first = "", ...rest] = text.split(`
+`);
+  const body = rest.join(`
+`).trim();
+  return { subject: first.trim(), ...body ? { body } : {} };
 }
 async function fastForwardFetched(repoPath, defaultBr) {
   const current = await git(repoPath, "branch", "--show-current");
@@ -32525,7 +32683,7 @@ async function fetchBase(worktreePath, repo, w = UNWATCHED) {
   w.step(`fetching ${base}`);
   const f = await w.git(worktreePath, ["fetch", "--quiet", tracked.remote, tracked.merge]);
   if (!f.ok)
-    return { ok: false, message: refused3("fetch failed", f) };
+    return { ok: false, message: refused2("fetch failed", f) };
   return { ok: true, message: `fetched ${base}` };
 }
 async function pushBranch(worktreePath, branch, w = UNWATCHED) {
@@ -32615,7 +32773,7 @@ function compareUrl(remoteUrl, base, branch) {
 }
 
 // ../daemon/src/git/turn.ts
-import { copyFileSync, existsSync as existsSync30, rmSync as rmSync6 } from "fs";
+import { copyFileSync, existsSync as existsSync31, 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";
@@ -32641,7 +32799,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 (!existsSync30(index))
+  if (!existsSync31(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) {
@@ -32656,9 +32814,9 @@ async function treeNow(wtPath, head, dirty) {
     }
   }
   synced.delete(wtPath);
-  if (!existsSync30(index)) {
+  if (!existsSync31(index)) {
     const own = join27(index, "..", "index");
-    if (existsSync30(own))
+    if (existsSync31(own))
       copyFileSync(own, index);
     else if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
       return null;
@@ -32739,8 +32897,8 @@ async function dropTurnRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync19, renameSync as renameSync5, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "fs";
-import { basename as basename10, dirname as dirname11, join as join28 } from "path";
+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 { basename as basename11, dirname as dirname11, join as join28 } from "path";
 class WorktreeArchive {
   dir;
   records = new Map;
@@ -32749,7 +32907,7 @@ class WorktreeArchive {
     mkdirSync8(dir, { recursive: true });
     for (const id of readdirSync9(dir)) {
       const file = this.filesOf(id).record;
-      if (!existsSync31(file))
+      if (!existsSync32(file))
         continue;
       try {
         this.records.set(id, JSON.parse(readFileSync19(file, "utf8")));
@@ -32807,8 +32965,8 @@ class WorktreeArchive {
   planFile(id, rel) {
     if (!this.records.has(id) || !isPlanPath(rel))
       return null;
-    const file = join28(this.filesOf(id).plans, basename10(rel));
-    if (!existsSync31(file))
+    const file = join28(this.filesOf(id).plans, basename11(rel));
+    if (!existsSync32(file))
       return null;
     try {
       return readFileSync19(file, "utf8");
@@ -32849,7 +33007,7 @@ function summarize(r, repoId, transcript) {
   };
 }
 function lastUsage(transcript) {
-  if (!existsSync31(transcript))
+  if (!existsSync32(transcript))
     return null;
   const lines = readFileSync19(transcript, "utf8").split(`
 `);
@@ -32865,7 +33023,7 @@ function lastUsage(transcript) {
   return null;
 }
 function firstPrompt(transcript) {
-  if (!existsSync31(transcript))
+  if (!existsSync32(transcript))
     return;
   for (const line of readFileSync19(transcript, "utf8").split(`
 `)) {
@@ -32880,7 +33038,7 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync31(from))
+  if (!existsSync32(from))
     return;
   mkdirSync8(dirname11(to), { recursive: true });
   rmSync7(to, { recursive: true, force: true });
@@ -33051,8 +33209,8 @@ async function fillLandMarks(jobs, read, width = 8) {
 }
 
 // ../daemon/src/worktrees/spare.ts
-import { existsSync as existsSync32 } from "fs";
-import { basename as basename11, join as join29 } from "path";
+import { existsSync as existsSync33 } from "fs";
+import { basename as basename12, join as join29 } from "path";
 class SparePool {
   d;
   inflight = new Map;
@@ -33071,7 +33229,7 @@ class SparePool {
     if (!text.trim())
       return;
     const wt = this.d.state.worktree(boxId);
-    if (wt?.kind !== "spare" || !existsSync32(wt.path))
+    if (wt?.kind !== "spare" || !existsSync33(wt.path))
       return;
     const agent = this.d.runtime.ensureAgent(wt).agent;
     if (agent.runningAgent === null)
@@ -33135,9 +33293,18 @@ class SparePool {
     const repoId = repo.id;
     let cut = () => {};
     const added = (async () => {
-      if (existsSync32(wt.path))
+      if (existsSync33(wt.path))
         return;
-      await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--detach", wt.path, baseOf(repo)));
+      const run = this.d.runs.begin(wt.id, "setup", {
+        timeoutMs: timeoutFor(repo.config, "setup"),
+        stage: "checking out"
+      });
+      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 {
+        run.finish(0);
+      }
     })();
     const done = (async () => {
       this.d.runtime.markSetup(wt.id, true);
@@ -33185,7 +33352,7 @@ class SparePool {
     }
     log.warn(wt.repoId, "spare warm-up failed; rolling back", e);
     this.d.carryDraft?.(wt.id, wt.repoId);
-    if (existsSync32(wt.path)) {
+    if (existsSync33(wt.path)) {
       await this.d.discard(wt.id).catch((re) => log.warn(wt.repoId, "spare rollback failed", re));
       return;
     }
@@ -33229,40 +33396,70 @@ class SparePool {
     this.refreshing.set(repoId, run);
     await run;
   }
-  async claim(repoId, title, worktreeId) {
+  async claim(repoId, title, worktreeId, stamps, prepare) {
     const wt = this.spareOf(repoId);
     if (!wt)
       return null;
     if (worktreeId && wt.id !== worktreeId)
       return null;
     const wasReady = wt.phase === "ready";
-    if (!wasReady) {
-      if (!worktreeId)
-        return null;
-      const running = this.inflight.get(repoId);
-      await running?.added.catch(() => {});
-      running?.cut();
-      if (wt.kind !== "spare" || !existsSync32(wt.path))
-        return null;
-    }
-    await this.refreshing.get(repoId);
+    if (!wasReady && !worktreeId)
+      return null;
     const repo = this.d.state.requireRepo(repoId);
-    const branch = `toyon/${basename11(wt.path)}`;
-    await withRepoLock(repo.path, () => gitOrThrow(wt.path, "switch", "-c", branch));
+    const running = this.inflight.get(repoId);
+    const was = { title: wt.title, branch: wt.branch, phase: wt.phase, lockfile: wt.lockfile };
     wt.kind = "worktree";
     delete wt.phase;
     delete wt.lockfile;
-    wt.branch = branch;
+    wt.branch = `toyon/${basename12(wt.path)}`;
     wt.title = title;
-    wt.unnamed = true;
     wt.createdAt = Date.now();
-    if (wasReady)
-      fireAndForget(wt.id, this.d.runtime.wake(wt.id), "wake on claim");
+    wt.promptedAt = wt.createdAt;
+    Object.assign(wt, Object.fromEntries(Object.entries(stamps).filter(([, v]) => v !== undefined)));
     const next = repo.needsSetup ? null : await this.record(repoId, repo);
     this.d.state.save();
     if (next)
       fireAndForget(repoId, this.warmUp(next, repo, { after: wt.id }), "spare reserve");
-    return wt;
+    const settled = (async () => {
+      try {
+        await running?.added;
+        running?.cut();
+        if (!existsSync33(wt.path))
+          throw new Error("the worktree's directory is gone");
+        await this.refreshing.get(repoId);
+        await prepare(wt);
+        await withRepoLock(repo.path, async () => {
+          await gitOrThrow(wt.path, "branch", wt.branch);
+          await gitOrThrow(wt.path, "symbolic-ref", "HEAD", `refs/heads/${wt.branch}`);
+        });
+        if (wasReady)
+          fireAndForget(wt.id, this.d.runtime.wake(wt.id), "wake on claim");
+      } catch (e) {
+        await this.unclaim(wt, was, stamps, next, e);
+        throw e;
+      }
+    })();
+    return { wt, settled };
+  }
+  async unclaim(wt, was, stamps, next, e) {
+    wt.kind = "spare";
+    wt.title = was.title;
+    wt.branch = was.branch;
+    if (was.phase)
+      wt.phase = was.phase;
+    if (was.lockfile)
+      wt.lockfile = was.lockfile;
+    for (const k of Object.keys(stamps))
+      delete wt[k];
+    delete wt.promptedAt;
+    if (!existsSync33(wt.path)) {
+      await this.rollBack(wt, e);
+      return;
+    }
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
+    if (next)
+      await this.d.discard(next.id).catch((re) => log.warn(wt.repoId, "reserved spare removal failed", re));
   }
 }
 
@@ -33340,7 +33537,7 @@ class Trunk {
     const f = await withFetchLock(repo.path, () => w.git(repo.path, ["fetch", "--quiet"]));
     this.noteFetch(repo.id, f);
     if (!f.ok)
-      return { ok: false, message: refused3("fetch failed", f) };
+      return { ok: false, message: refused2("fetch failed", f) };
     this.d.invalidateCounts();
     return this.follow(main.id);
   }
@@ -33400,23 +33597,8 @@ class TurnService {
   stoppedByHand = new Set;
   constructor(d) {
     this.d = d;
-    this.boot();
     d.hub.on("agentStatus", (worktreeId, status) => this.onStatus(worktreeId, status));
   }
-  boot() {
-    let changed = false;
-    for (const wt of this.d.state.worktrees) {
-      const turn = wt.lastTurn;
-      if (turn?.end !== "asking")
-        continue;
-      const { ask: _expired, ...facts } = turn.facts;
-      turn.end = "stopped";
-      turn.facts = facts;
-      changed = true;
-    }
-    if (changed)
-      this.d.state.save();
-  }
   onStatus(worktreeId, status) {
     const prev = this.lastStatus.get(worktreeId) ?? "idle";
     this.lastStatus.set(worktreeId, status);
@@ -33503,6 +33685,7 @@ var idsOf = (rows, trunks) => [
   ...rows.map((r) => r.id),
   ...Object.values(trunks).map((t) => t.id)
 ];
+var heldBy = (found) => `${found.name} is held by another tool${found.lockReason ? `: ${found.lockReason}` : ""}`;
 var commandLine = (args) => args.map((a) => /^[\w./:=@,+-]+$/.test(a) ? a : JSON.stringify(a.split(`
 `, 1)[0])).join(" ");
 
@@ -33517,6 +33700,8 @@ class WorktreeService {
   archiving = new Map;
   restoring = new Map;
   going = new Set;
+  arriving = new Set;
+  firstPrompt = new Map;
   counts;
   handChecked = new Map;
   naming = new Set;
@@ -33531,7 +33716,7 @@ class WorktreeService {
     this.archive = new WorktreeArchive(d.paths.archiveDir);
     this.counts = new Counts({
       read: (id) => this.readCounts(id),
-      going: (id) => this.going.has(id)
+      going: (id) => this.going.has(id) || this.arriving.has(id)
     });
     this.trunk = new Trunk({
       state: d.state,
@@ -33544,6 +33729,7 @@ class WorktreeService {
       hub: d.hub,
       runtime: d.runtime,
       paths: d.paths,
+      runs: this.runs,
       setupAndStart: (wt, repo) => this.setupAndStart(wt, repo),
       teardown: (wt, repo) => this.teardown(wt, repo),
       discard: async (id) => {
@@ -33615,39 +33801,55 @@ class WorktreeService {
     const agentPrompt = variant && variant.of >= 2 ? [prompt, variantLens(variant.index)].filter(Boolean).join(`
 
 `) : prompt;
-    const claimed = await this.spare.claim(repoId, title, opts.worktreeId);
-    if (claimed) {
-      if (variant)
-        claimed.variant = variant;
-      if (opts.createdBy)
-        claimed.createdBy = opts.createdBy;
-      if (given)
-        delete claimed.unnamed;
-      if (opts.from)
-        claimed.from = opts.from;
-      claimed.promptedAt = claimed.createdAt;
-      claimed.agent = agent;
-      if (opts.mode)
-        claimed.mode = opts.mode;
-      if (opts.model)
-        claimed.model = opts.model;
-      if (opts.effort)
-        claimed.effort = opts.effort;
-      if (profile !== undefined && profile !== resolveRun(repo, claimed).profile) {
-        claimed.profile = profile;
-        this.restartProcs(claimed);
-      }
-      const carried = await this.carryMain(repo, claimed, !!opts.carry);
-      this.d.state.save();
-      this.d.hub.emit("worktreesChanged");
-      const rt = this.d.runtime.ensureAgent(claimed);
+    const spare = this.d.state.worktrees.find((w) => w.repoId === repoId && w.kind === "spare");
+    const restart = !!spare && profile !== undefined && profile !== resolveRun(repo, spare).profile;
+    let carriedIn;
+    let release;
+    const stamps = {
+      createdBy: opts.createdBy,
+      agent,
+      mode: opts.mode,
+      model: opts.model,
+      effort: opts.effort,
+      variant,
+      from: opts.from,
+      profile,
+      unnamed: given ? undefined : true
+    };
+    const claimed = await this.spare.claim(repoId, title, opts.worktreeId, stamps, async (wt) => {
+      const rt = this.d.runtime.ensureAgent(wt);
+      release = rt.agent.hold();
       if (rt.agent.runningAgent !== null && rt.agent.runningAgent !== agent)
         await rt.agent.restart();
-      rt.agent.send(agentPrompt, { context: withCarry(context(claimed.id), carried), attachments });
-      this.nameOrAsk(claimed, task, given, variant);
-      if (carried.unmoved)
-        throw new UserError(carried.unmoved, { delivered: true });
-      return claimed;
+      carriedIn = await this.carryMain(repo, wt, !!opts.carry);
+      rt.agent.send(agentPrompt, { context: withCarry(context(wt.id), carriedIn), attachments });
+    });
+    if (claimed) {
+      const { wt } = claimed;
+      const rt = this.d.runtime.ensureAgent(wt);
+      this.firstPrompt.set(wt.id, claimed.settled.then(() => {
+        return;
+      }, () => {
+        return;
+      }));
+      this.d.hub.emit("worktreesChanged");
+      try {
+        await claimed.settled;
+      } catch (e) {
+        if (carriedIn && rt.agent.queueLength > 0)
+          rt.agent.unqueue(0);
+        release?.();
+        throw e instanceof UserError ? e : new UserError(e instanceof Error ? e.message : String(e));
+      } finally {
+        this.firstPrompt.delete(wt.id);
+      }
+      release?.();
+      if (restart)
+        this.restartProcs(wt);
+      this.nameOrAsk(wt, task, given, variant);
+      if (carriedIn?.unmoved)
+        throw new UserError(carriedIn.unmoved, { delivered: true });
+      return wt;
     }
     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.`);
@@ -33730,7 +33932,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) => !existsSync33(join30(wt.path, p)));
+`).filter(Boolean) : []).filter((p) => !existsSync34(join30(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -33770,7 +33972,7 @@ class WorktreeService {
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
     let slug = branchSlug(title) || "branch";
-    if (existsSync33(join30(this.d.paths.worktreesDir, repo.name, slug)))
+    if (existsSync34(join30(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
     const wtPath = join30(this.d.paths.worktreesDir, repo.name, slug);
     await withRepoLock(repo.path, async () => {
@@ -33808,8 +34010,9 @@ class WorktreeService {
     this.launch(wt, repo, repo.path);
     return wt;
   }
-  async requireDiscovered(repoId, repoPath, target) {
-    const rows = await discoverIn(repoId, repoPath, this.d.state.worktrees);
+  async requireDiscovered(repoId, repoPath, target, except) {
+    const known = this.d.state.worktrees.filter((w) => w.id !== except);
+    const rows = await discoverIn(repoId, repoPath, known);
     const found = rows.find((r) => canonical(r.path) === target);
     if (!found)
       throw new UserError("that worktree is gone, or Toyon already has it");
@@ -33824,38 +34027,50 @@ class WorktreeService {
     const repoId = r.repoId;
     const repo = this.d.state.requireRepo(repoId);
     const target = canonical(r.path);
-    const wt = await withRepoLock(repo.path, async () => {
-      const found = await this.requireDiscovered(repoId, repo.path, target);
-      if (found.locked) {
-        throw new UserError(`${found.name} is held by another tool${found.lockReason ? `: ${found.lockReason}` : ""}`);
-      }
-      if (!found.branch)
-        throw new UserError(`${found.name} is detached: check out a branch in it first`);
-      const enclosing = [...this.d.state.repos, ...this.d.state.worktrees].find((r) => isInside(target, canonical(r.path)));
-      if (enclosing)
-        throw new UserError(`${found.name} sits inside ${enclosing.path}, which Toyon already manages`);
-      const rec = {
-        id: shortId(),
-        repoId,
-        path: found.path,
-        branch: found.branch,
-        kind: "worktree",
-        proxyPort: await allocateProxyPort(),
-        title: found.name,
-        createdAt: Date.now(),
-        agent: this.d.agents.require(this.d.state.defaultAgent ?? DEFAULT_AGENT_ID).id,
-        parked: true,
-        ...message ? { promptedAt: Date.now() } : {},
-        ...createdBy ? { createdBy } : {}
-      };
-      return rec;
-    });
+    const pushed = this.discoveredById(worktreeId);
+    if (pushed?.locked)
+      throw new UserError(heldBy(pushed));
+    if (!r.branch)
+      throw new UserError(`${r.name} is detached: check out a branch in it first`);
+    const enclosing = [...this.d.state.repos, ...this.d.state.worktrees].find((w) => isInside(target, canonical(w.path)));
+    if (enclosing)
+      throw new UserError(`${r.name} sits inside ${enclosing.path}, which Toyon already manages`);
+    const wt = {
+      id: shortId(),
+      repoId,
+      path: r.path,
+      branch: r.branch,
+      kind: "worktree",
+      proxyPort: await allocateProxyPort(),
+      title: r.name,
+      createdAt: Date.now(),
+      agent: this.d.agents.require(this.d.state.defaultAgent ?? DEFAULT_AGENT_ID).id,
+      parked: true,
+      ...message ? { promptedAt: Date.now() } : {},
+      ...createdBy ? { createdBy } : {}
+    };
+    const { rt, release } = this.listAhead(wt, message);
     this.invalidateDiscovered();
-    this.launch(wt, repo, repo.path, { setupCommands: false });
-    const { agent } = this.d.runtime.ensureAgent(wt);
-    agent.note({ type: "adopted", branch: wt.branch, ts: Date.now() });
-    if (message)
-      agent.send(message.text, { attachments: message.attachments });
+    this.d.hub.emit("worktreesChanged");
+    try {
+      await withRepoLock(repo.path, async () => {
+        const found = await this.requireDiscovered(repoId, repo.path, target, wt.id);
+        if (found.locked)
+          throw new UserError(heldBy(found));
+        if (!found.branch)
+          throw new UserError(`${found.name} is detached: check out a branch in it first`);
+        wt.branch = found.branch;
+      });
+    } catch (e) {
+      await this.unlist(wt, !!message);
+      this.invalidateDiscovered();
+      this.d.hub.emit("worktreesChanged");
+      throw e;
+    }
+    this.d.state.save();
+    fireAndForget(wt.id, this.setupAndStart(wt, repo, repo.path, { setupCommands: false }), "setup + start");
+    rt.agent.note({ type: "adopted", branch: wt.branch, ts: Date.now() });
+    release();
     return wt;
   }
   async ownProcs(worktreeId, names) {
@@ -34025,7 +34240,7 @@ class WorktreeService {
   }
   async teardown(wt, repo) {
     const cmds = repo.config.teardown ?? [];
-    if (cmds.length === 0 || !existsSync33(wt.path))
+    if (cmds.length === 0 || !existsSync34(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") });
@@ -34075,7 +34290,7 @@ class WorktreeService {
   }
   keepPlans(wt) {
     const from = join30(wt.path, PLANS_DIR);
-    if (!existsSync33(from))
+    if (!existsSync34(from))
       return;
     try {
       cpSync(from, this.plansScratch(wt.id), { recursive: true });
@@ -34269,79 +34484,126 @@ 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 = existsSync33(old.path) ? join30(dirname12(old.path), freeSlot(dirname12(old.path)).dir) : old.path;
-    const branch = await withRepoLock(repo.path, async () => {
-      if (!await commitOf(repo.path, archiveRef(old.id))) {
-        throw new UserError(`${old.title}'s kept commits are gone from git`);
-      }
-      let name = old.branch;
-      let create = true;
-      const tip = await commitOf(repo.path, `refs/heads/${name}`);
-      if (tip && hasOwnBranch(old)) {
-        name = `${name}-${shortId().slice(0, 3)}`;
-      } else if (tip) {
-        if (tip !== kept.head && kept.snapshot) {
-          throw new UserError(`${name} has moved since ${old.title} was archived: check it out in git instead`);
-        }
-        create = false;
-      }
-      try {
-        await checkOutKept(repo.path, path, kept, { name, create });
-      } catch (e) {
-        await git(repo.path, "worktree", "remove", "--force", path);
-        if (create)
-          await git(repo.path, "branch", "-D", name);
-        throw e;
-      }
-      return name;
-    });
+    const path = existsSync34(old.path) ? join30(dirname12(old.path), freeSlot(dirname12(old.path)).dir) : old.path;
     const { variant: _variant, ...rest } = old;
     const wt = {
       ...rest,
       repoId: repo.id,
       path,
-      branch,
+      branch: old.branch,
       proxyPort: await allocateProxyPort(),
       promptedAt: Date.now(),
       parked: true,
       ...createdBy ? { createdBy } : {}
     };
+    const chat = { ...this.chatFiles(old.id), plans: this.plansScratch(old.id) };
     try {
-      this.archive.take(old.id, { ...this.chatFiles(old.id), plans: join30(path, PLANS_DIR) });
+      this.archive.take(old.id, chat);
     } catch (e) {
       log.warn(old.id, "could not move its chat back out of the archive", e);
+      throw new UserError(`could not move ${old.title}'s chat back out of the archive`);
     }
     if (rec.sessionId && path === old.path)
       this.d.state.setSession(wt.id, rec.sessionId);
+    this.arriving.add(wt.id);
+    const { rt, release } = this.listAhead(wt, message);
+    const run = this.runs.begin(wt.id, "setup", {
+      timeoutMs: timeoutFor(repo.config, "setup"),
+      stage: "checking out the branch"
+    });
+    this.d.hub.emit("worktreesChanged");
+    this.d.hub.emit("archiveChanged", repo.id);
+    let branch;
+    try {
+      branch = await withRepoLock(repo.path, () => this.checkOutArchived(repo, old, kept, path));
+    } catch (e) {
+      await this.takeBack(wt, rec, chat, run, !!message);
+      throw e;
+    }
+    run.finish(0);
+    this.arriving.delete(wt.id);
+    wt.branch = branch;
+    move(chat.plans, join30(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.launch(wt, repo, repo.path);
-    this.d.runtime.ensureAgent(wt).agent.note({
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
+    fireAndForget(wt.id, this.setupAndStart(wt, repo, repo.path), "setup + start");
+    rt.agent.note({
       type: "restored",
       archivedAt: rec.archivedAt,
       branch,
       uncommitted: !!kept.snapshot,
       ts: Date.now()
     });
-    if (message)
-      this.d.runtime.ensureAgent(wt).agent.send(message.text, { attachments: message.attachments });
-    this.d.hub.emit("archiveChanged", repo.id);
+    release();
+    this.d.hub.emit("filesChanged", wt.id);
     return wt;
   }
+  async checkOutArchived(repo, old, kept, path) {
+    if (!await commitOf(repo.path, archiveRef(old.id))) {
+      throw new UserError(`${old.title}'s kept commits are gone from git`);
+    }
+    let name = old.branch;
+    let create = true;
+    const tip = await commitOf(repo.path, `refs/heads/${name}`);
+    if (tip && hasOwnBranch(old)) {
+      name = `${name}-${shortId().slice(0, 3)}`;
+    } else if (tip) {
+      if (tip !== kept.head && kept.snapshot) {
+        throw new UserError(`${name} has moved since ${old.title} was archived: check it out in git instead`);
+      }
+      create = false;
+    }
+    try {
+      await checkOutKept(repo.path, path, kept, { name, create });
+    } catch (e) {
+      await git(repo.path, "worktree", "remove", "--force", path);
+      if (create)
+        await git(repo.path, "branch", "-D", name);
+      throw e;
+    }
+    return name;
+  }
+  listAhead(wt, message) {
+    this.d.runtime.markSetup(wt.id, true);
+    this.d.state.addWorktree(wt);
+    const rt = this.d.runtime.ensureAgent(wt);
+    const release = rt.agent.hold();
+    if (message)
+      rt.agent.send(message.text, { attachments: message.attachments });
+    return { rt, release };
+  }
+  async takeBack(wt, rec, chat, run, queued) {
+    run.finish(0);
+    await this.unlist(wt, queued);
+    this.arriving.delete(wt.id);
+    this.archive.put(rec, chat);
+    this.d.hub.emit("worktreesChanged");
+    this.d.hub.emit("archiveChanged", wt.repoId);
+  }
+  async unlist(wt, queued) {
+    const agent = this.d.runtime.agentFor(wt.id);
+    if (queued && agent && agent.queueLength > 0)
+      agent.unqueue(0);
+    await this.d.runtime.stop(wt.id);
+    this.d.state.removeWorktree(wt.id, { refused: true });
+    releasePort(wt.proxyPort);
+  }
   async deleteArchived(archiveId) {
     const rec = this.archive.get(archiveId);
     if (!rec)
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync33(repoPath)) {
+    if (rec.kept && existsSync34(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 && existsSync33(repoPath))
+    if (rec.worktree.lands?.length && existsSync34(repoPath))
       await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
     this.d.drafts?.drop(archiveId);
@@ -34450,8 +34712,8 @@ class WorktreeService {
   }
   async mirrorBaseIgnore(repo) {
     const src = join30(repo.path, ".gitignore");
-    const tracked = existsSync33(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
-    const mirror = existsSync33(src) && !tracked;
+    const tracked = existsSync34(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
+    const mirror = existsSync34(src) && !tracked;
     const lines = mirror ? readFileSync20(src, "utf8").split(`
 `).filter((l) => l.trim() !== "") : [];
     await excludeBlock(repo.path, BASE_IGNORE, lines);
@@ -34466,8 +34728,10 @@ class WorktreeService {
     }
     const srcNm = join30(depsSource, "node_modules");
     const dstNm = join30(wt.path, "node_modules");
-    if (existsSync33(srcNm) && !existsSync33(dstNm)) {
+    if (existsSync34(srcNm) && !existsSync34(dstNm)) {
+      const run = this.runs.begin(wt.id, "setup", { timeoutMs: ceiling, stage: "copying dependencies" });
       const r = await cloneTree(srcNm, dstNm);
+      run.finish(0);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `deps via ${r.how} in ${r.ms}ms`);
       else
@@ -34475,7 +34739,7 @@ class WorktreeService {
     }
     for (const f of LOCAL_CONFIG_FILES) {
       const src = join30(depsSource, f);
-      if (!existsSync33(src) || existsSync33(join30(wt.path, f)))
+      if (!existsSync34(src) || existsSync34(join30(wt.path, f)))
         continue;
       const r = await run("cp", [src, join30(wt.path, f)], wt.path);
       if (r.ok)
@@ -34746,9 +35010,10 @@ ${wt.landing.body}` : s;
     const policy = landPolicy(repo.config);
     const own = hasOwnBranch(wt);
     const w = this.landWatch(wt);
-    const suggested = wt.landing?.subject ? wt.landing.body ? `${wt.landing.subject}
+    const typed = message?.trim();
+    const suggested = typed || (wt.landing?.subject ? wt.landing.body ? `${wt.landing.subject}
 
-${wt.landing.body}` : wt.landing.subject : undefined;
+${wt.landing.body}` : wt.landing.subject : undefined);
     const base = baseOf(repo);
     if (policy.land === "pr") {
       if (wt.pr?.state === "merged" && !prTaken(wt)) {
@@ -34792,13 +35057,14 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
         const result = { ...r, message: r.ok ? `${on}; ${r.message}` : `${on}, but ${r.message}` };
         return r.ok ? { result, archiveIds: this.siblingIds(wt), mark: noted } : { result };
       }
+      const named = !suggested ? undefined : splitMessage(policy.merge === "squash" ? await squashMessage(wt.path, base, suggested, !!typed) : suggested);
       const result = await openPr({
         worktreePath: wt.path,
         branch: wt.branch,
         defaultBr: repo.defaultBranch,
         base,
-        subject: wt.landing?.subject,
-        body: wt.landing?.body,
+        subject: named?.subject,
+        body: named?.body,
         automerge: policy.automerge,
         method: policy.merge
       }, w);
@@ -34827,7 +35093,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       if (!taken.ok)
         return taken;
       const mark = await landingMark(wt.path, base);
-      const squash = method === "squash" ? await squashMessage(wt.path, base, suggested) : "";
+      const squash = method === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : "";
       const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash, w);
       if (!landed.ok)
         return landed;
@@ -34878,7 +35144,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
         sha = await commitOf(wt.path, base) ?? "";
         break;
       }
-      squash = method === "squash" ? await squashMessage(wt.path, base, suggested) : "";
+      squash = method === "squash" ? await squashMessage(wt.path, base, suggested, !!message?.trim()) : "";
       const built = await landingCommit(wt.path, wt.branch, base, method, squash, own, w);
       await this.headMoved(wt.id);
       if (!built.ok || !built.sha)
@@ -34930,8 +35196,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   async landedWhat(repo, wt, mark, opts) {
     if (opts.pr?.title)
       return [opts.pr.title];
-    const subject = opts.squash?.split(`
-`)[0]?.trim();
+    const subject = opts.squash ? splitMessage(opts.squash).subject : "";
     if (subject)
       return [subject];
     const read = await rangeSubjects(repo.path, mark.base, mark.tip);
@@ -34949,7 +35214,8 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const r = await git(wt.path, "reset", "--keep", base);
     if (!r.ok)
       log.warn(wt.id, `could not restart ${wt.branch} from ${base}: ${r.err}`);
-    await this.headMoved(wt.id);
+    this.counts.stale(wt.id);
+    await this.counts.refresh([wt.id]);
   }
   async fetchBase(wt, repo, w) {
     if (!baseIsRemote(repo))
@@ -35238,7 +35504,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       await markTurn(wt.path, wt.id);
   }
   async gitStatus(worktreeId) {
-    if (this.going.has(worktreeId))
+    if (this.going.has(worktreeId) || this.arriving.has(worktreeId))
       return null;
     const r = this.readable(worktreeId);
     if (!r)
@@ -35281,7 +35547,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       }
       if (r.wt && isMain)
         this.setEmpty(r.wt, files.length === 0 ? await treeEmpty(r.path) : false);
-      if (this.going.has(worktreeId))
+      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 };
@@ -35327,6 +35593,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const wt = this.requireRun(worktreeId);
     if (wt.kind === "main")
       throw new UserError("nothing runs on main: the plus starts a worktree for it");
+    await this.firstPrompt.get(worktreeId);
     const agent = this.d.runtime.agentFor(worktreeId);
     if (!agent)
       throw new UserError("worktree still starting; try again in a moment");
@@ -35532,7 +35799,8 @@ var {
   helperStub: HELPER_STUB,
   cliEntry: CLI_ENTRY,
   sourceRoot: SOURCE_ROOT,
-  packageJson: PACKAGE_JSON
+  packageJson: PACKAGE_JSON,
+  changelog: CHANGELOG
 } = locateAssets(here);
 var pruned = pruneAssets(SHELL_DIST);
 if (pruned > 0)
@@ -35540,7 +35808,7 @@ if (pruned > 0)
 var managed = await loadManaged();
 var paths = makePaths();
 ensureDirs(paths);
-forwardTranscripts(paths.transcriptsDir);
+forwardTranscripts([paths.transcriptsDir, paths.archiveDir], join31(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);
@@ -35581,43 +35849,39 @@ await linuxSandbox.refresh();
 var agents = loadAgentRegistry(paths.agentsFile, paths.agentsDir, linuxSandbox, managed.policy);
 if (state.defaultAgent !== undefined && !agents.get(state.defaultAgent))
   state.clearDefaultAgent();
-var probe2 = new OptionProbe({
+var readiness2 = new AgentReadiness({
   infos: () => agents.infos(),
   require: (id) => agents.require(id),
-  connect: async (app, spec) => spawnAcp(app, agents.launch(spec, await prepareLaunch(paths.scratchDir, spec)), paths.scratchDir, `probe:${spec.id}`),
+  connect: async (app, spec) => spawnAcp(app, agents.launch(spec, await prepareLaunch(paths.scratchDir, spec)), paths.scratchDir, `check:${spec.id}`),
   cwd: paths.scratchDir,
-  known: (id) => state.cachedOptions(id, "model").length > 0,
+  options: (id, category) => state.cachedOptions(id, category),
   learned: (id, category, choices) => {
     if (state.setCachedOptions(id, category, choices))
       hub.emit("agentsChanged");
+  },
+  quick: (id) => {
+    const spec = agents.get(id);
+    return !!spec && !lacksQuickModel(spec, state);
   }
 });
+readiness2.onChange = () => hub.emit("agentsChanged");
 agents.onChange = () => {
   hub.emit("agentsChanged");
-  fireAndForget("agents", probe2.missing(), "read agent models");
+  fireAndForget("agents", readiness2.checkMissing(), "read agent models");
 };
-var accounts = new AgentAccounts({
-  require: (id) => agents.require(id),
-  connect: async (app, spec) => spawnAcp(app, agents.launch(spec, await prepareLaunch(paths.scratchDir, spec)), paths.scratchDir, `auth:${spec.id}`)
-});
-accounts.onChange = () => hub.emit("agentsChanged");
 var uploads = new UploadStore(paths.uploadsDir);
 var attachments2 = new AttachmentStore(paths.attachmentsDir, uploads);
 var mcpPort = port;
 var tools = new ToolSet;
 var mcp = new ToyonMcp({ url: (id) => `http://127.0.0.1:${mcpPort}/mcp/${id}`, version: package_default.version, tools });
-var pageErrors = new PageErrorService({
-  hub,
-  runtime: { agentFor: (id) => runtime.agentFor(id) },
-  known: (id) => state.worktree(id) !== undefined
-});
+var pageErrors = new PageErrorService({ hub, known: (id) => state.worktree(id) !== undefined });
 var runtime = new RuntimeRegistry({
   hub,
   state,
   paths,
   agents,
   managed: managed.policy,
-  accounts,
+  readiness: readiness2,
   attachments: attachments2,
   bridgeScript: () => bridge.get(),
   pageErrors: (id) => pageErrors.ambient(id),
@@ -35660,8 +35924,6 @@ var handoff2 = new HandoffService({
   create: (repoId, prompt, opts) => worktrees.create(repoId, prompt, opts)
 });
 tools.add(handoff2);
-var render = new RenderService({ runtime, pageErrors });
-tools.add(render);
 var turns = new TurnService({
   state,
   hub,
@@ -35776,6 +36038,7 @@ var {
   port,
   token,
   shellDist: SHELL_DIST,
+  changelog: CHANGELOG,
   version: package_default.version,
   noteShellOrigin: (origin) => bridge.learnShellOrigin(origin),
   startLink: () => helper?.startLink() ?? null,
@@ -35819,12 +36082,11 @@ var {
     landing,
     fix,
     pageErrors,
-    render,
     handoff: handoff2,
     mcp,
     themes,
     agents,
-    accounts,
+    readiness: readiness2,
     attachments: attachments2,
     self,
     afterLand,
@@ -35855,7 +36117,7 @@ idle.boot();
 runs.boot();
 landing.boot();
 fireAndForget("cache", cache.sweep(), "cache sweep");
-fireAndForget("agents", agents.installMissing().then(() => probe2.missing()), "agent adapter install");
+fireAndForget("agents", agents.installMissing().then(() => readiness2.checkMissing()), "agent adapter install");
 var repoArg = process.argv[2];
 if (repoArg) {
   try {