toyon 0.14.0 → 0.15.0

package/dist/daemon.js

@@ -29,7 +29,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,7 +6602,7 @@ ${text.slice(text.length - (CONTEXT_CHARS - HEAD_CHARS))}`;
 }
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 107;
+var PROTOCOL_VERSION = 109;
 var PAGE_ERROR_MAX_CHARS = 2000;
 var PAGE_TITLE_MAX_CHARS = 1000;
 var RENDER_ERRORS_MAX = 10;
@@ -6961,6 +6961,7 @@ 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("stop-agent"), worktreeId: id }),
   object({ t: literal("seen"), worktreeId: id }),
   object({ t: literal("mark-unread"), worktreeId: id }),
@@ -8528,7 +8529,7 @@ async function turnRemoteOff(ts, daemonPort, file, was) {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.14.0",
+  version: "0.15.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -14435,11 +14436,27 @@ var BUILTIN_AGENTS = [
     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 +14472,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);
   }
@@ -14521,22 +14541,26 @@ class AgentRegistry {
     }
   }
   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 = isAbsolute(cmd) ? existsSync8(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 +14588,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 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 {
+        mkdirSync5(dir, { recursive: true });
+        writeFileSync4(join6(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,6 +14620,11 @@ 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)
@@ -14609,22 +14644,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,6 +14682,7 @@ class AgentRegistry {
         available: !reason,
         ...reason ? { reason } : {},
         ...this.installing.has(spec.id) ? { installing: true } : {},
+        ...install !== undefined ? { install } : {},
         ...spec.onDemand ? { onDemand: true } : {},
         sandboxed: spec.confinement !== "none"
       };
@@ -14720,6 +14771,18 @@ 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";
@@ -15091,14 +15154,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 +15187,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 +15319,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)
@@ -16424,6 +16489,7 @@ class AcpSession {
     this.queue = [];
     this.steered = [];
     this.queueChanged();
+    this.cancelAsks("expired");
     this.stop();
     await this.dropConn("closing");
     await this.log.flush();
@@ -16864,6 +16930,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") {
@@ -16936,7 +17005,7 @@ class AcpSession {
     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 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 +17091,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")
@@ -19504,7 +19573,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 +19581,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 +19611,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) {
@@ -19804,7 +19897,8 @@ function locateAssets(here, env = process.env) {
     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;
@@ -21063,9 +21157,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);
@@ -23291,6 +23385,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) => {
@@ -23390,13 +23487,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 +23566,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 +23575,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;
@@ -28859,6 +29042,9 @@ 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 "discard-files"(msg, _ctx, s) {
     try {
       for (const path of msg.paths)
@@ -29365,6 +29551,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;
@@ -29880,7 +30080,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 +30098,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));
       },
@@ -30228,7 +30430,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 +30582,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();
@@ -31370,6 +31572,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 +31648,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 +31721,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 +31762,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 +31778,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 +31793,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 +31802,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 +31820,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 +31852,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 +31873,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(`
@@ -32403,17 +32645,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");
@@ -33137,7 +33403,16 @@ class SparePool {
     const added = (async () => {
       if (existsSync32(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);
@@ -33229,40 +33504,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/${basename11(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 (!existsSync32(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 (!existsSync32(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));
   }
 }
 
@@ -33400,23 +33705,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 +33793,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 +33808,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 +33824,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 +33837,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 +33909,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.`);
@@ -33808,8 +34118,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 +34135,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) {
@@ -34270,66 +34593,113 @@ class WorktreeService {
     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 { 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)
@@ -34467,7 +34837,9 @@ class WorktreeService {
     const srcNm = join30(depsSource, "node_modules");
     const dstNm = join30(wt.path, "node_modules");
     if (existsSync33(srcNm) && !existsSync33(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
@@ -34746,9 +35118,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 +35165,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 +35201,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 +35252,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 +35304,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);
@@ -35238,7 +35611,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 +35654,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 +35700,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 +35906,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)
@@ -35776,6 +36151,7 @@ var {
   port,
   token,
   shellDist: SHELL_DIST,
+  changelog: CHANGELOG,
   version: package_default.version,
   noteShellOrigin: (origin) => bridge.learnShellOrigin(origin),
   startLink: () => helper?.startLink() ?? null,