toyon 0.8.1 → 0.10.0

package/dist/daemon.js

@@ -1,6 +1,6 @@
 // @bun
 // ../daemon/src/index.ts
-import { rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
+import { rmSync as rmSync8, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname12 } from "path";
 import { fileURLToPath } from "url";
 
@@ -58,6 +58,7 @@ function applyLog(lines, proc, line, retract = 0) {
     return out;
   return [...out, { proc, line }];
 }
+var KEEP_AWAKE_MODES = ["use", "always", "off"];
 
 // ../shared/src/worktree-caps.ts
 function isMain(wt) {
@@ -119,9 +120,10 @@ function archiveReason(wt, f) {
     return null;
   if (unitsAhead(wt, f.rows) < ARCHIVE_KEEP_RECENT)
     return null;
-  const what = lost ? "a sibling landed" : wt.landed ? "landed" : "no changes";
-  return `${what}, not opened in ${duration(f.afterMs)}`;
+  const what = lost ? "sibling landed" : wt.landed ? "landed" : "no changes";
+  return `${what}, ${UNOPENED}${duration(f.afterMs)}`;
 }
+var UNOPENED = "not opened in ";
 function nothingToKeep(w, f, lost) {
   if (w.kind !== "worktree" || !hasOwnBranch(w))
     return false;
@@ -157,22 +159,30 @@ function duration(ms) {
 }
 
 // ../shared/src/attachment.ts
-var ATTACHMENT_KINDS = ["image", "paste", "pick"];
-var ATTACHMENT_LIMITS = { image: 6, paste: 4, pick: 8 };
+var ATTACHMENT_KINDS = ["image", "paste", "file", "pick"];
+var ATTACHMENT_LIMITS = { image: 6, paste: 4, file: 8, pick: 8 };
 var ATTACHMENTS_PER_MESSAGE = ATTACHMENT_KINDS.reduce((sum, k) => sum + ATTACHMENT_LIMITS[k], 0);
-var KIND_NOUN = { image: "image", paste: "paste", pick: "element" };
+var KIND_NOUN = {
+  image: "image",
+  paste: "paste",
+  file: "file",
+  pick: "element"
+};
 var KIND_LABEL = { image: "Image", paste: "Pasted text" };
 var attachmentLabel = (kind, n) => `${KIND_LABEL[kind]} ${n}`;
 var limitMessage = (kind) => `at most ${ATTACHMENT_LIMITS[kind]} ${KIND_NOUN[kind]}s per message`;
 var countOf = (list, kind) => list.filter((a) => a.kind === kind).length;
 var overLimit = (list) => ATTACHMENT_KINDS.find((k) => countOf(list, k) > ATTACHMENT_LIMITS[k]) ?? null;
 function nextNumbers(sent) {
-  const next = { image: 1, paste: 1, pick: 1 };
+  const next = { image: 1, paste: 1, file: 1, pick: 1 };
   for (const list of sent)
     for (const a of list ?? [])
       next[a.kind] = Math.max(next[a.kind], a.n + 1);
   return next;
 }
+function fmtBytes(n) {
+  return n >= 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(n / 1024))} KB`;
+}
 
 // ../shared/src/cache.ts
 function cachePolicy(config) {
@@ -6464,17 +6474,33 @@ function describeManaged(p) {
   return out;
 }
 
+// ../shared/src/output.ts
+var CONTEXT_CHARS = 6000;
+var HEAD_CHARS = 1500;
+function clipOutput(text) {
+  if (text.length <= CONTEXT_CHARS)
+    return text;
+  const cut = text.length - CONTEXT_CHARS;
+  return `${text.slice(0, HEAD_CHARS)}
+[${cut} characters cut here]
+${text.slice(text.length - (CONTEXT_CHARS - HEAD_CHARS))}`;
+}
+
 // ../shared/src/pair.ts
 var PAIR_TTL_MS = 120000;
 var pairLink = (host, code) => `https://${host}/#pair=${code}`;
+var isTailnetName = (host) => host.endsWith(".ts.net");
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 83;
+var PROTOCOL_VERSION = 89;
 var FILE_MAX_CHARS = 5000000;
 var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var IMAGE_MAX_EDGE = 2576;
 var IMAGE_MAX_BYTES = 5 * 1024 * 1024;
 var PASTE_MAX_CHARS = 1e5;
+var FILE_INLINE_CHARS = 20000;
+var UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
+var VARIANTS_MAX = 3;
 
 // ../shared/src/paste.ts
 var PREVIEW_CHARS = 80;
@@ -6559,11 +6585,13 @@ var termInput = string2().max(65536);
 var streamName = string2().min(1).max(100);
 var routePath = string2().min(1).max(2000);
 var pageTitle = string2().max(1000);
+var uploadId = string2().regex(/^[A-Za-z0-9_-]{1,64}$/);
 var imageInputSchema = object({
   kind: literal("image"),
   name: string2().max(200),
   mimeType: _enum(IMAGE_MIME_TYPES),
-  data: string2().max(Math.ceil(IMAGE_MAX_BYTES * 4 / 3 / 4) * 4),
+  upload: uploadId,
+  bytes: number2().int().min(1).max(IMAGE_MAX_BYTES),
   width: number2().int().min(1).max(IMAGE_MAX_EDGE),
   height: number2().int().min(1).max(IMAGE_MAX_EDGE)
 });
@@ -6579,6 +6607,13 @@ var pasteInputSchema = object({
   name: string2().max(200).optional(),
   source: pasteSourceSchema.optional()
 });
+var fileInputSchema = object({
+  kind: literal("file"),
+  upload: uploadId,
+  name: string2().min(1).max(200),
+  bytes: number2().int().min(1).max(UPLOAD_MAX_BYTES),
+  text: boolean2()
+});
 var pickInputSchema = pickMetaSchema.extend({
   kind: literal("pick"),
   text: string2().max(120),
@@ -6587,13 +6622,16 @@ var pickInputSchema = pickMetaSchema.extend({
 var attachmentInputSchema = discriminatedUnion("kind", [
   imageInputSchema,
   pasteInputSchema,
+  fileInputSchema,
   pickInputSchema
 ]);
-var attachments = array(attachmentInputSchema).max(ATTACHMENTS_PER_MESSAGE).superRefine((list, ctx) => {
+var attachmentList = array(attachmentInputSchema).max(ATTACHMENTS_PER_MESSAGE).superRefine((list, ctx) => {
   const over = overLimit(list);
   if (over)
     ctx.addIssue({ code: "custom", message: limitMessage(over) });
-}).optional();
+});
+var attachments = attachmentList.optional();
+var boxId = id.optional();
 var askAnswerSchema = object({
   selected: array(string2().max(2000)).max(32),
   note: string2().max(1e4).optional()
@@ -6702,7 +6740,6 @@ var themePrefsSchema = object({
   light: string2(),
   dark: string2()
 });
-var variantSchema = object({ group: string2(), index: number2().int().min(1), of: number2().int().min(1) });
 var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("subscribe"), worktreeId: id }),
   object({ t: literal("unsubscribe"), worktreeId: id }),
@@ -6713,7 +6750,8 @@ var clientMsgSchema = discriminatedUnion("t", [
     clientId: string2().max(64).optional(),
     text: prose,
     context: ambient.optional(),
-    attachments
+    attachments,
+    boxId
   }),
   object({
     t: literal("create-worktree"),
@@ -6721,7 +6759,7 @@ var clientMsgSchema = discriminatedUnion("t", [
     repoId: id,
     worktreeId: id.optional(),
     prompt,
-    variant: variantSchema.optional(),
+    variants: number2().int().min(1).max(VARIANTS_MAX).optional(),
     context: ambient.optional(),
     attachments,
     agent: id.optional(),
@@ -6729,7 +6767,8 @@ var clientMsgSchema = discriminatedUnion("t", [
     mode: permissionModeSchema.optional(),
     model: string2().max(200).optional(),
     effort: string2().max(100).optional(),
-    carry: boolean2().optional()
+    carry: boolean2().optional(),
+    boxId
   }),
   object({
     t: literal("batch-worktrees"),
@@ -6737,7 +6776,8 @@ var clientMsgSchema = discriminatedUnion("t", [
     prompt,
     agent: id.optional(),
     model: string2().max(200).optional(),
-    effort: string2().max(100).optional()
+    effort: string2().max(100).optional(),
+    boxId
   }),
   object({ t: literal("set-worktree-mode"), worktreeId: id, mode: permissionModeSchema }),
   object({ t: literal("set-worktree-model"), worktreeId: id, model: string2().max(200) }),
@@ -6751,16 +6791,26 @@ var clientMsgSchema = discriminatedUnion("t", [
     t: literal("restore-worktree"),
     archiveId: id,
     clientId: string2().max(64).optional(),
-    message: object({ text: prose, attachments }).optional()
+    message: object({ text: prose, attachments }).optional(),
+    boxId
   }),
   object({ t: literal("delete-archived"), archiveId: id }),
   object({
     t: literal("adopt-worktree"),
     clientId: string2().max(64).optional(),
-    worktreeId: id
+    worktreeId: id,
+    message: object({ text: prose, attachments }).optional(),
+    boxId
   }),
   object({ t: literal("git-status"), worktreeId: id }),
-  object({ t: literal("read-file"), worktreeId: id, path: relPath, ref: sha.optional(), seq }),
+  object({
+    t: literal("read-file"),
+    worktreeId: id,
+    path: relPath,
+    ref: sha.optional(),
+    since: sha.optional(),
+    seq
+  }),
   object({ t: literal("blame-file"), worktreeId: id, path: relPath, ref: sha.optional(), seq }),
   object({ t: literal("git-log"), worktreeId: id }),
   object({ t: literal("git-commit"), worktreeId: id, sha }),
@@ -6796,17 +6846,31 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("design-scan"), worktreeId: id }),
   object({ t: literal("discard-files"), worktreeId: id, paths: array(relPath).min(1).max(500) }),
   object({ t: literal("judge"), worktreeId: id, note: string2().max(500).optional() }),
+  object({ t: literal("fix-preview"), worktreeId: id, clientId: string2().max(64).optional() }),
+  object({ t: literal("fix"), worktreeId: id, toolId: string2().min(1).max(200) }),
   object({ t: literal("reveal"), worktreeId: id, path: relPath.optional() }),
   object({ t: literal("stop-agent"), worktreeId: id }),
   object({ t: literal("seen"), worktreeId: id }),
   object({ t: literal("mark-unread"), worktreeId: id }),
   object({ t: literal("set-draft"), boxId: id, text: prose, clientId: string2().max(64).optional() }),
+  object({
+    t: literal("set-attachments"),
+    boxId: id,
+    items: attachmentList,
+    clientId: string2().max(64).optional()
+  }),
   object({ t: literal("refresh-git"), repoId: id }),
   object({ t: literal("visit"), worktreeId: id, path: routePath, title: pageTitle.optional() }),
   object({ t: literal("page-title"), worktreeId: id, path: routePath, title: pageTitle }),
   object({ t: literal("forget-visit"), repoId: id, path: routePath }),
   object({ t: literal("pick-variant"), worktreeId: id }),
-  object({ t: literal("unqueue"), worktreeId: id, index: number2().int().min(0) }),
+  object({
+    t: literal("unqueue"),
+    worktreeId: id,
+    index: number2().int().min(0),
+    edit: boolean2().optional()
+  }),
+  object({ t: literal("redraft"), worktreeId: id, seq: number2().int().min(0) }),
   object({ t: literal("changed-ranges"), worktreeId: id, path: relPath }),
   object({ t: literal("rename-worktree"), worktreeId: id, title: string2().min(1).max(200) }),
   object({
@@ -6842,6 +6906,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("set-theme"), prefs: themePrefsSchema }),
   object({ t: literal("zone"), tz: string2().max(100) }),
   object({ t: literal("set-default-agent"), agent: id }),
+  object({ t: literal("set-keep-awake"), mode: _enum(KEEP_AWAKE_MODES) }),
   object({ t: literal("install-agent"), agent: id }),
   object({
     t: literal("agent-auth"),
@@ -6870,6 +6935,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("exec"), worktreeId: id, command: shellCommand.min(1) }),
   object({ t: literal("exec-stop"), worktreeId: id, toolId: id }),
   object({ t: literal("run-stop"), worktreeId: id, kind: _enum(["setup", "check", "commit"]) }),
+  object({ t: literal("preview-start"), worktreeId: id }),
   object({ t: literal("search-refs"), repoId: id, query: string2().max(200) }),
   object({ t: literal("search-chats"), repoId: id, query: string2().max(200) }),
   object({
@@ -8154,7 +8220,7 @@ function safeUser() {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.8.1",
+  version: "0.10.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -12248,9 +12314,11 @@ var legacyClientNotificationMethods = new Set([
 
 // ../daemon/src/core/errors.ts
 class UserError extends Error {
-  constructor(message) {
+  delivered;
+  constructor(message, about = {}) {
     super(message);
     this.name = "UserError";
+    this.delivered = about.delivered ?? false;
   }
 }
 
@@ -12503,18 +12571,177 @@ function spawnAcp(app, launch, cwd, tag) {
 
 // ../daemon/src/agent/attachments.ts
 import { createHash } from "crypto";
-import { mkdir, writeFile } from "fs/promises";
+import { copyFile as copyFile2, mkdir, readFile, stat, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+
+// ../daemon/src/agent/uploads.ts
+import { randomBytes } from "crypto";
+import { mkdirSync, readdirSync, rmSync } from "fs";
+import { copyFile } from "fs/promises";
 import { join } from "path";
-var EXT = {
+var IMAGE_EXT = {
   "image/png": "png",
   "image/jpeg": "jpg",
   "image/gif": "gif",
   "image/webp": "webp"
 };
+var MIME_OF_EXT = new Map(IMAGE_MIME_TYPES.map((mime) => [IMAGE_EXT[mime], mime]));
+var OTHER_EXT = "bin";
+var NAME = /^([A-Za-z0-9_-]{1,64})\.(png|jpg|gif|webp|bin)$/;
+var UNNAMED_MS = 10 * 60000;
+var GONE = "an attachment is no longer on this machine; attach it again";
+var isUploadKind = (kind) => kind === "image" || kind === "file";
+function uploadIds(items) {
+  return (items ?? []).flatMap((a) => a.kind === "image" || a.kind === "file" ? [a.upload] : []);
+}
+
+class UploadStore {
+  dir;
+  unnamedMs;
+  files = new Map;
+  holds = new Map;
+  named = new Set;
+  constructor(dir, unnamedMs = UNNAMED_MS) {
+    this.dir = dir;
+    this.unnamedMs = unnamedMs;
+    mkdirSync(dir, { recursive: true });
+    for (const file of readdirSync(dir)) {
+      const id = NAME.exec(file)?.[1];
+      if (id)
+        this.files.set(id, file);
+    }
+  }
+  async put(kind, mime, body) {
+    const image = IMAGE_EXT[mime];
+    if (kind === "image" && !image)
+      throw new UserError("not an image format the models accept");
+    const cap = kind === "image" ? IMAGE_MAX_BYTES : UPLOAD_MAX_BYTES;
+    const upload = randomBytes(12).toString("base64url");
+    const file = `${upload}.${kind === "image" ? image : OTHER_EXT}`;
+    const path = join(this.dir, file);
+    const writer = Bun.file(path).writer();
+    let decoder = kind === "file" ? new TextDecoder("utf-8", { fatal: true }) : null;
+    let bytes = 0;
+    try {
+      for await (const chunk of body ?? []) {
+        bytes += chunk.byteLength;
+        if (bytes > cap)
+          throw new UserError(`larger than ${fmtBytes(cap)}`);
+        writer.write(chunk);
+        await writer.flush();
+        if (decoder && (bytes > FILE_MAX_CHARS || !decodes(decoder, chunk)))
+          decoder = null;
+      }
+      if (bytes === 0)
+        throw new UserError("empty file");
+      await writer.end();
+    } catch (e) {
+      await Promise.resolve(writer.end()).catch(() => {});
+      rmSync(path, { force: true });
+      throw e;
+    }
+    this.files.set(upload, file);
+    this.expireUnnamed(upload);
+    return { upload, bytes, text: decoder !== null };
+  }
+  async adopt(from, image) {
+    const upload = randomBytes(12).toString("base64url");
+    const file = `${upload}.${image ? IMAGE_EXT[image] : OTHER_EXT}`;
+    await copyFile(from, join(this.dir, file));
+    this.files.set(upload, file);
+    this.expireUnnamed(upload);
+    return upload;
+  }
+  expireUnnamed(id) {
+    const timer = setTimeout(() => {
+      if (!this.named.has(id) && !this.holds.has(id))
+        this.remove(id);
+    }, this.unnamedMs);
+    timer.unref?.();
+  }
+  path(id) {
+    const file = this.files.get(id);
+    return file ? join(this.dir, file) : null;
+  }
+  imageType(id) {
+    const file = this.files.get(id);
+    return file && MIME_OF_EXT.get(file.slice(file.lastIndexOf(".") + 1)) || null;
+  }
+  has(id) {
+    return this.files.has(id);
+  }
+  hold(ids) {
+    if (ids.some((id) => !this.files.has(id)))
+      throw new UserError(GONE);
+    for (const id of ids)
+      this.holds.set(id, (this.holds.get(id) ?? 0) + 1);
+  }
+  release(ids) {
+    for (const id of ids) {
+      const left = (this.holds.get(id) ?? 0) - 1;
+      if (left > 0) {
+        this.holds.set(id, left);
+        continue;
+      }
+      this.holds.delete(id);
+      if (!this.named.has(id))
+        this.remove(id);
+    }
+  }
+  keep(named) {
+    const before = this.named;
+    this.named = new Set(named);
+    for (const id of before)
+      if (!this.named.has(id) && !this.holds.has(id))
+        this.remove(id);
+  }
+  sweep(named) {
+    this.named = new Set(named);
+    for (const id of [...this.files.keys()])
+      if (!this.named.has(id))
+        this.remove(id);
+  }
+  remove(id) {
+    const file = this.files.get(id);
+    if (!file)
+      return;
+    this.files.delete(id);
+    try {
+      rmSync(join(this.dir, file), { force: true });
+    } catch (e) {
+      log.warn("uploads", `could not delete ${file}`, e);
+    }
+  }
+}
+function decodes(decoder, chunk) {
+  try {
+    decoder.decode(chunk, { stream: true });
+    return !chunk.includes(0);
+  } catch {
+    return false;
+  }
+}
+
+// ../daemon/src/agent/attachments.ts
 var ID = /^[A-Za-z0-9_-]{1,64}$/;
-var FILE = /^(\d{1,6}|[0-9a-f]{16})\.(png|jpg|gif|webp|txt)$/;
+var NAME_MAX = 80;
+var DRAWN = /^(?:\d{1,6}|[0-9a-f]{16})\.(png|jpg|gif|webp|txt)$/;
+var NAMED = new RegExp(`^\\d{1,6}-[A-Za-z0-9._-]{1,${NAME_MAX}}$`);
+var isFile = (file) => DRAWN.test(file) || NAMED.test(file);
+var MIME = { png: "image/png", jpg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
+function drawnType(file) {
+  return MIME[DRAWN.exec(file)?.[1] ?? ""] ?? null;
+}
+function storedName(name) {
+  const safe = name.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^\.+/, "") || "file";
+  if (safe.length <= NAME_MAX)
+    return safe;
+  const dot = safe.lastIndexOf(".");
+  const ext = dot > 0 && safe.length - dot <= 16 ? safe.slice(dot) : "";
+  return safe.slice(0, NAME_MAX - ext.length) + ext;
+}
 function toolImage(data, mimeType) {
-  const ext = EXT[mimeType];
+  const ext = IMAGE_EXT[mimeType];
   if (!ext)
     return null;
   const bytes = Buffer.from(data, "base64");
@@ -12523,27 +12750,40 @@ function toolImage(data, mimeType) {
   const file = `${createHash("sha256").update(bytes).digest("hex").slice(0, 16)}.${ext}`;
   return { ref: { file, mimeType, bytes: bytes.length }, bytes };
 }
-var isAttachmentFile = (file) => FILE.test(file);
+var isAttachmentFile = (file) => isFile(file);
 function attachmentsDirFor(attachmentsDir, worktreeId) {
-  return join(attachmentsDir, worktreeId);
+  return join2(attachmentsDir, worktreeId);
+}
+var GONE2 = "the upload is gone; attach it again";
+async function shortText(path, bytes) {
+  if (bytes > FILE_INLINE_CHARS * 4)
+    return null;
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(await readFile(path));
+    return text.length <= FILE_INLINE_CHARS ? text : null;
+  } catch {
+    return null;
+  }
 }
 
 class AttachmentStore {
   dir;
+  uploads;
   pending = new Map;
-  constructor(dir) {
+  constructor(dir, uploads) {
     this.dir = dir;
+    this.uploads = uploads;
   }
   async putToolImage(worktreeId, file, bytes) {
-    if (!ID.test(worktreeId) || !FILE.test(file))
+    if (!ID.test(worktreeId) || !DRAWN.test(file))
       throw new UserError("bad tool image");
-    const path = join(attachmentsDirFor(this.dir, worktreeId), file);
+    const path = join2(attachmentsDirFor(this.dir, worktreeId), file);
     if (this.pending.has(path) || await Bun.file(path).exists())
       return;
-    await this.write(worktreeId, file, bytes);
+    await this.write(worktreeId, file, (path) => writeFile(path, bytes));
   }
   whenWritten(worktreeId, file) {
-    return this.pending.get(join(attachmentsDirFor(this.dir, worktreeId), file)) ?? Promise.resolve();
+    return this.pending.get(join2(attachmentsDirFor(this.dir, worktreeId), file)) ?? Promise.resolve();
   }
   async put(worktreeId, n, input) {
     if (!ID.test(worktreeId))
@@ -12553,19 +12793,23 @@ class AttachmentStore {
         return this.putImage(worktreeId, n, input);
       case "paste":
         return this.putText(worktreeId, n, input);
+      case "file":
+        return this.putFile(worktreeId, n, input);
       case "pick":
         return { kind: "pick", ref: { ...input, n } };
     }
   }
   async putImage(worktreeId, n, img) {
-    const bytes = Buffer.from(img.data, "base64");
-    if (bytes.length === 0)
-      throw new UserError(`${img.name}: empty image`);
-    const file = `${n}.${EXT[img.mimeType]}`;
-    await this.write(worktreeId, file, bytes);
+    const from = this.uploads.path(img.upload);
+    if (!from || this.uploads.imageType(img.upload) !== img.mimeType)
+      throw new UserError(`${img.name}: ${GONE2}`);
+    const bytes = await readFile(from);
+    const file = `${n}.${IMAGE_EXT[img.mimeType]}`;
+    const path = await this.write(worktreeId, file, (to) => writeFile(to, bytes));
     return {
       kind: "image",
       bytes,
+      path,
       ref: {
         kind: "image",
         n,
@@ -12578,28 +12822,78 @@ class AttachmentStore {
       }
     };
   }
+  async putFile(worktreeId, n, input) {
+    const from = this.uploads.path(input.upload);
+    if (!from)
+      throw new UserError(`${input.name}: ${GONE2}`);
+    const file = `${n}-${storedName(input.name)}`;
+    const path = await this.write(worktreeId, file, (to) => copyFile2(from, to));
+    const bytes = (await stat(path)).size;
+    const text = input.text ? await shortText(path, bytes) : null;
+    return {
+      kind: "file",
+      path,
+      ...text === null ? {} : { text },
+      ref: { kind: "file", n, name: input.name, bytes, text: input.text, file }
+    };
+  }
   async putText(worktreeId, n, { text, name, source }) {
     if (text.length === 0)
       throw new UserError("empty paste");
     const file = `${n}.txt`;
-    await this.write(worktreeId, file, text);
+    await this.write(worktreeId, file, (to) => writeFile(to, text));
     return {
       kind: "paste",
       text,
       ref: { kind: "paste", n, ...name ? { name } : {}, ...source ? { source } : {}, ...pasteSummary(text), file }
     };
   }
-  write(worktreeId, file, data) {
+  async reattach(worktreeId, ref, archived) {
+    const again = await this.inputOf(worktreeId, ref, archived);
+    const parsed = attachmentInputSchema.safeParse(again);
+    return parsed.success ? parsed.data : null;
+  }
+  async inputOf(worktreeId, ref, archived) {
+    if (ref.kind === "pick") {
+      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;
+      }
+    }
+    if (!path)
+      return null;
+    if (ref.kind === "paste") {
+      const { name, source } = ref;
+      return { kind: "paste", text: await readFile(path, "utf8"), name, source };
+    }
+    if (ref.kind === "file") {
+      const upload = await this.uploads.adopt(path, null);
+      return { kind: "file", upload, name: ref.name, bytes: ref.bytes, text: ref.text };
+    }
+    const mimeType = IMAGE_MIME_TYPES.find((m) => m === ref.mimeType);
+    if (!mimeType)
+      return null;
+    const upload = await this.uploads.adopt(path, mimeType);
+    const { name, bytes, width, height } = ref;
+    return { kind: "image", upload, name, mimeType, bytes, width, height };
+  }
+  async write(worktreeId, file, fill) {
     const wtDir = attachmentsDirFor(this.dir, worktreeId);
-    const path = join(wtDir, file);
-    const done = mkdir(wtDir, { recursive: true }).then(() => writeFile(path, data)).finally(() => this.pending.delete(path));
+    const path = join2(wtDir, file);
+    const done = mkdir(wtDir, { recursive: true }).then(() => fill(path)).finally(() => this.pending.delete(path));
     this.pending.set(path, done);
-    return done;
+    await done;
+    return path;
   }
   fileFor(worktreeId, file) {
-    if (!ID.test(worktreeId) || !FILE.test(file))
+    if (!ID.test(worktreeId) || !isFile(file))
       return null;
-    return join(attachmentsDirFor(this.dir, worktreeId), file);
+    return join2(attachmentsDirFor(this.dir, worktreeId), file);
   }
 }
 
@@ -12756,9 +13050,9 @@ class OptionProbe {
 }
 
 // ../daemon/src/agent/registry.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, isAbsolute, join as join5, resolve as resolve3 } from "path";
+import { dirname as dirname3, isAbsolute, join as join6, resolve as resolve3 } from "path";
 
 // ../daemon/src/core/cloud.ts
 var enabled = process.env.TOYON_CLOUD === "1";
@@ -12785,7 +13079,7 @@ var cloud = {
 import { spawn as spawn2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // ../daemon/src/core/metrics.ts
 var WARN_MS = 50;
@@ -12827,7 +13121,7 @@ function lockfileHash(dir) {
   const h = createHash2("sha1");
   for (const f of LOCKFILES) {
     try {
-      h.update(readFileSync2(join2(dir, f)));
+      h.update(readFileSync2(join3(dir, f)));
     } catch {}
   }
   return h.digest("hex");
@@ -12939,8 +13233,9 @@ async function runLive(cmd, args, cwd, opts = {}) {
   }
 }
 function watchHooks(stream, onHook) {
+  let failed;
   if (!stream)
-    return;
+    return () => failed;
   const dec = new TextDecoder;
   let buf = "";
   const open = new Map;
@@ -12961,11 +13256,15 @@ function watchHooks(stream, onHook) {
       if (ev.event === "child_start" && ev.child_class === "hook" && ev.hook_name) {
         open.set(ev.child_id, ev.hook_name);
         onHook(ev.hook_name);
-      } else if (ev.event === "child_exit" && open.delete(ev.child_id)) {
+      } else if (ev.event === "child_exit" && open.has(ev.child_id)) {
+        if (ev.code)
+          failed = open.get(ev.child_id);
+        open.delete(ev.child_id);
         onHook(open.size > 0 ? [...open.values()].pop() : undefined);
       }
     }
   });
+  return () => failed;
 }
 function runWatched(cmd, args, cwd, opts = {}) {
   const started = Date.now();
@@ -13010,8 +13309,7 @@ function runWatched(cmd, args, cwd, opts = {}) {
     };
     if (child.pid)
       opts.onSpawn?.(child.pid, kill);
-    if (opts.onHook)
-      watchHooks(child.stdio[3], opts.onHook);
+    const failedHook = opts.onHook ? watchHooks(child.stdio[3], opts.onHook) : undefined;
     if (opts.timeoutMs) {
       timer = setTimeout(() => {
         timedOut = true;
@@ -13047,7 +13345,8 @@ function runWatched(cmd, args, cwd, opts = {}) {
         err: err.join("").trim(),
         exit,
         text,
-        ...timedOut && opts.timeoutMs ? { ceilingMs: opts.timeoutMs } : {}
+        ...timedOut && opts.timeoutMs ? { ceilingMs: opts.timeoutMs } : {},
+        ...failedHook?.() ? { hook: failedHook() } : {}
       });
     });
   });
@@ -13142,7 +13441,7 @@ function confine(launch, b, extraWrite = [], platform = process.platform, which
 }
 
 // ../daemon/src/agent/native.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
 var OS = { darwin: "darwin", linux: "linux", win32: "windows" };
 function nativePackage(pkg, host) {
   const os = OS[host.platform];
@@ -13165,7 +13464,7 @@ function hostTraits() {
 }
 function muslLoader() {
   try {
-    return existsSync2("/lib") && readdirSync("/lib").some((f) => f.startsWith("ld-musl-"));
+    return existsSync2("/lib") && readdirSync2("/lib").some((f) => f.startsWith("ld-musl-"));
   } catch {
     return false;
   }
@@ -13235,49 +13534,52 @@ function opencodeEnv() {
 }
 
 // ../daemon/src/agent/sandbox.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2, tmpdir } from "os";
-import { join as join4, resolve as resolve2 } from "path";
+import { join as join5, resolve as resolve2 } from "path";
 
 // ../daemon/src/core/paths.ts
-import { mkdirSync } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
 import { homedir } from "os";
-import { join as join3 } from "path";
-function makePaths(home = process.env.TOYON_HOME ?? join3(homedir(), ".toyon")) {
+import { join as join4 } from "path";
+function makePaths(home = process.env.TOYON_HOME ?? join4(homedir(), ".toyon")) {
   return {
     home,
-    stateFile: join3(home, DAEMON_FILES.state),
-    draftsFile: join3(home, DAEMON_FILES.drafts),
-    tokenFile: join3(home, DAEMON_FILES.token),
-    pidFile: join3(home, DAEMON_FILES.pid),
-    logFile: join3(home, DAEMON_FILES.log),
-    remoteFile: join3(home, DAEMON_FILES.remote),
-    transcriptsDir: join3(home, "transcripts"),
-    attachmentsDir: join3(home, "attachments"),
-    archiveDir: join3(home, "archive"),
-    worktreesDir: join3(home, "worktrees.noindex"),
-    cacheDir: join3(home, "cache.noindex"),
-    themesDir: join3(home, "themes"),
-    agentsDir: process.env.TOYON_AGENTS_DIR ?? join3(home, "agents"),
-    agentsFile: join3(home, "agents.json"),
-    scratchDir: join3(home, "scratch"),
-    gitCredentialsFile: join3(home, "git-credentials")
+    stateFile: join4(home, DAEMON_FILES.state),
+    draftsFile: join4(home, DAEMON_FILES.drafts),
+    draftAttachmentsFile: join4(home, "draft-attachments.json"),
+    tokenFile: join4(home, DAEMON_FILES.token),
+    pidFile: join4(home, DAEMON_FILES.pid),
+    logFile: join4(home, DAEMON_FILES.log),
+    remoteFile: join4(home, DAEMON_FILES.remote),
+    transcriptsDir: join4(home, "transcripts"),
+    attachmentsDir: join4(home, "attachments"),
+    uploadsDir: join4(home, "uploads"),
+    archiveDir: join4(home, "archive"),
+    worktreesDir: join4(home, "worktrees.noindex"),
+    cacheDir: join4(home, "cache.noindex"),
+    themesDir: join4(home, "themes"),
+    agentsDir: process.env.TOYON_AGENTS_DIR ?? join4(home, "agents"),
+    agentsFile: join4(home, "agents.json"),
+    scratchDir: join4(home, "scratch"),
+    gitCredentialsFile: join4(home, "git-credentials")
   };
 }
 function ensureDirs(p) {
-  mkdirSync(p.home, { recursive: true, mode: 448 });
-  mkdirSync(p.transcriptsDir, { recursive: true });
-  mkdirSync(p.attachmentsDir, { recursive: true });
-  mkdirSync(p.archiveDir, { recursive: true });
-  mkdirSync(p.worktreesDir, { recursive: true });
-  mkdirSync(p.cacheDir, { recursive: true });
-  mkdirSync(p.themesDir, { recursive: true });
-  mkdirSync(p.agentsDir, { recursive: true });
-  mkdirSync(p.scratchDir, { recursive: true });
+  mkdirSync2(p.home, { recursive: true, mode: 448 });
+  mkdirSync2(p.transcriptsDir, { recursive: true });
+  mkdirSync2(p.attachmentsDir, { recursive: true });
+  mkdirSync2(p.uploadsDir, { recursive: true });
+  mkdirSync2(p.archiveDir, { recursive: true });
+  mkdirSync2(p.worktreesDir, { recursive: true });
+  mkdirSync2(p.cacheDir, { recursive: true });
+  mkdirSync2(p.themesDir, { recursive: true });
+  mkdirSync2(p.agentsDir, { recursive: true });
+  mkdirSync2(p.scratchDir, { recursive: true });
 }
 
 // ../daemon/src/git/exclude.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { dirname } from "path";
 async function excludeFile(cwd) {
   const r = await git(cwd, "rev-parse", "--path-format=absolute", "--git-path", "info/exclude");
@@ -13294,7 +13596,7 @@ async function excludeFromGit(cwd, pattern) {
   if (current.split(`
 `).some((l) => l.trim() === pattern))
     return;
-  mkdirSync2(dirname(file), { recursive: true });
+  mkdirSync3(dirname(file), { recursive: true });
   writeFileSync(file, `${current}${current && !current.endsWith(`
 `) ? `
 ` : ""}${pattern}
@@ -13320,7 +13622,7 @@ async function excludeBlock(cwd, name, patterns) {
 ` : "";
   if (text === current)
     return;
-  mkdirSync2(dirname(file), { recursive: true });
+  mkdirSync3(dirname(file), { recursive: true });
   writeFileSync(file, text);
 }
 async function unexcludeFromGit(cwd, pattern) {
@@ -13387,7 +13689,7 @@ async function prepareLaunch(cwd, spec) {
     log.warn(cwd, `agent ${spec.id} runs without an OS sandbox`);
   return { bounds, env: setup?.env ?? {} };
 }
-var SETTINGS_REL = join4(".claude", "settings.local.json");
+var SETTINGS_REL = join5(".claude", "settings.local.json");
 function claudeLocalSettings(b) {
   return {
     sandbox: {
@@ -13401,8 +13703,8 @@ function claudeLocalSettings(b) {
   };
 }
 async function writeClaudeLocalSettings(cwd, b) {
-  const file = join4(cwd, SETTINGS_REL);
-  mkdirSync3(join4(cwd, ".claude"), { recursive: true });
+  const file = join5(cwd, SETTINGS_REL);
+  mkdirSync4(join5(cwd, ".claude"), { recursive: true });
   let existing = {};
   if (existsSync5(file)) {
     try {
@@ -13424,7 +13726,7 @@ async function writeClaudeLocalSettings(cwd, b) {
   writeFileSync2(tmp, `${JSON.stringify(next, null, 2)}
 `);
   renameSync(tmp, file);
-  if (existsSync5(join4(cwd, ".git")))
+  if (existsSync5(join5(cwd, ".git")))
     await excludeFromGit(cwd, SETTINGS_REL);
 }
 
@@ -13549,12 +13851,12 @@ class AgentRegistry {
     const name = this.packageName(spec);
     if (!name || spec.run.kind === "command")
       return null;
-    const pkgDir = join5(this.dir, spec.id, "node_modules", name);
+    const pkgDir = join6(this.dir, spec.id, "node_modules", name);
     if (spec.run.kind === "npm-native") {
-      const bin = join5(pkgDir, spec.run.bin);
+      const bin = join6(pkgDir, spec.run.bin);
       return existsSync6(bin) ? bin : null;
     }
-    const pkgJson = join5(pkgDir, "package.json");
+    const pkgJson = join6(pkgDir, "package.json");
     if (!existsSync6(pkgJson))
       return null;
     try {
@@ -13562,7 +13864,7 @@ class AgentRegistry {
       const rel = typeof meta.bin === "string" ? meta.bin : meta.bin?.[spec.run.bin];
       if (!rel)
         return null;
-      const script = join5(dirname3(pkgJson), rel);
+      const script = join6(dirname3(pkgJson), rel);
       return existsSync6(script) ? script : null;
     } catch (e) {
       log.warn("agents", `cannot read ${pkgJson}`, e);
@@ -13616,10 +13918,10 @@ class AgentRegistry {
     if (this.installed(spec) && this.installedVersion(spec) === spec.run.version)
       return Promise.resolve();
     const { version } = spec.run;
-    const dir = join5(this.dir, id);
+    const dir = join6(this.dir, id);
     const p = (async () => {
-      mkdirSync4(dir, { recursive: true });
-      writeFileSync3(join5(dir, "package.json"), `${JSON.stringify({ name: `toyon-agent-${id}`, private: true, dependencies: { [pkg]: version } }, null, 2)}
+      mkdirSync5(dir, { recursive: true });
+      writeFileSync3(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);
@@ -13643,7 +13945,7 @@ class AgentRegistry {
     const name = this.packageName(spec);
     if (!name)
       return null;
-    const pkgJson = join5(this.dir, spec.id, "node_modules", name, "package.json");
+    const pkgJson = join6(this.dir, spec.id, "node_modules", name, "package.json");
     try {
       return JSON.parse(readFileSync6(pkgJson, "utf8")).version ?? null;
     } catch {
@@ -13773,6 +14075,12 @@ ${body}
   return parts.join(`
 `);
 }
+function unformatOutput(output) {
+  if (!output.startsWith("```\n"))
+    return "";
+  const close = output.lastIndexOf("\n```");
+  return close < 4 ? "" : output.slice(4, close);
+}
 
 // ../daemon/src/agent/policy.ts
 import { isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
@@ -13881,6 +14189,7 @@ var SYSTEM_APPEND = [
   "Never run `git commit` unless the user explicitly asks you to, and never offer to, through the question tool or otherwise; leave changes uncommitted for the user to review and commit themselves.",
   "Keep the scope tight: do the asked task well, then stop. A follow-up the user might want later is a sentence in your reply, not a question.",
   "When the work is done and the only thing left is whether to do something you recommend, do not end your turn on a prose offer waiting for a yes. Ask it with your question tool when you have one: one question, two options with the recommended one first, each saying what it changes, and typed text allowed so the answer can carry instructions. The card is the first thing the user reads, before any prose of yours, so the question itself states what you propose and why in a sentence or two; a question that is only the yes-or-no leaves them guessing what it is. Ask this way only where you would otherwise have stopped and waited; never to confirm work already asked for.",
+  "An answer to a question of yours can carry typed text beside the option picked, and the text outranks the pick. Text that doubts the pick, asks you something or says the user cannot decide is not a yes: answer it in prose and change nothing until they have decided. Text that only adds detail to the pick is an instruction for carrying it out.",
   "When referencing a file in chat, use a Markdown link whose target is its absolute path, with an optional `:line`; Toyon opens it in the built-in editor, whether it is in this worktree or anywhere else on this machine. A folder, a URL route or a command is not a file: name it in backticks, never as a link.",
   "`@some/path` in a message means read that file or directory first; `@changes` means this worktree's uncommitted files, which `git status` lists.",
   '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.',
@@ -13888,6 +14197,113 @@ var SYSTEM_APPEND = [
   "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(" ");
+function failedRun(f) {
+  switch (f.kind) {
+    case "hook":
+    case "check":
+    case "command":
+      return f;
+    case "conflict":
+      return f.step;
+    case "preview":
+      return;
+  }
+}
+function fixPrompt(f) {
+  switch (f.kind) {
+    case "hook":
+      return hookFixPrompt(f.hook);
+    case "conflict":
+      return conflictFixPrompt(f.base, f.how, !!f.step);
+    case "check":
+      return checkFixPrompt(f.command);
+    case "command":
+      return commandFixPrompt(f.command);
+    case "preview":
+      return procFixPrompt(f.procs, f.log);
+  }
+}
+var WHY_COMMAND_CHARS = 60;
+function fixWhy(f) {
+  switch (f.kind) {
+    case "hook":
+      return `the ${f.hook} hook refused the ${f.hook.includes("push") ? "push" : "commit"}`;
+    case "conflict":
+      return f.how === "rebase" ? `the branch needs a rebase onto ${f.base}` : `the branch needs ${f.base} merged in`;
+    case "check":
+      return "the check failed";
+    case "command": {
+      const line = f.command.split(`
+`)[0] ?? "";
+      return `\`${line.length > WHY_COMMAND_CHARS ? `${line.slice(0, WHY_COMMAND_CHARS)}...` : line}\` failed`;
+    }
+    case "preview":
+      return "the dev server is not reachable";
+  }
+}
+function failureContext(f) {
+  const run = failedRun(f);
+  if (!run)
+    return;
+  const shown = clipOutput(run.text.replace(/\n+$/, ""));
+  const what = f.kind === "command" ? "The command that failed" : "What Toyon ran";
+  return `${what}, and what it printed:
+$ ${run.command}${shown ? `
+${shown}` : `
+(it printed nothing)`}`;
+}
+function hookFixPrompt(hook) {
+  return [
+    `The ${hook} hook refused that, and what it printed is attached below.`,
+    "Fix what it complains about, inside this worktree.",
+    "Do not skip the hook, do not edit it or its configuration to get past it, and do not commit: Toyon runs the check when your turn ends, and the user lands from there."
+  ].join(" ");
+}
+function conflictFixPrompt(base, how, shown) {
+  const ask = how === "rebase" ? `Rebase this branch onto ${base} and resolve the conflicts, keeping any uncommitted changes, then verify the app still works.` : `Merge ${base} into this branch, resolve the conflicts and commit the merge, then verify the app still works.`;
+  return shown ? `${ask} What git printed when Toyon tried is attached below.` : ask;
+}
+function checkFixPrompt(command) {
+  return [
+    `The repo's check, \`${command}\`, failed, and what it printed is attached below.`,
+    "Fix what it reports, inside this worktree.",
+    "Do not weaken the check or its configuration to get past it. Toyon runs it again when your turn ends."
+  ].join(" ");
+}
+function commandFixPrompt(command) {
+  return [
+    `The user ran \`${command}\` and it failed; what it printed is attached below.`,
+    "Find the cause and fix it, inside this worktree.",
+    "If the cause is not in this worktree, say what it is instead of changing anything."
+  ].join(" ");
+}
+var PROC_TAIL = 40;
+function procFixPrompt(procs, log) {
+  const bad = procs.filter((p) => p.status === "crashed" || p.status === "unreachable");
+  const lines = bad.map((p) => `- \`${p.name}\`: \`${p.command}\`, started with PORT=${p.port}. ${procDiagnosis(p)}`);
+  const tail = log.slice(-PROC_TAIL).map((l) => `[${l.proc}] ${l.line}`).join(`
+`);
+  return [
+    "The dev server in this worktree is not reachable, so the preview is empty.",
+    "",
+    ...lines,
+    "",
+    tail ? `Last output:
+\`\`\`
+${tail}
+\`\`\`` : "It produced no output.",
+    "",
+    "Find the cause and fix it. The command must run in the foreground and listen on the port in the PORT environment variable, which Toyon sets differently for each worktree. If the tool takes its port from a flag instead (Vite does), make the app read PORT, for Vite `server.port: Number(process.env.PORT)` with `strictPort: true`, or add the flag to the start command in toyon's settings file. When your turn ends toyon restarts the process and checks again."
+  ].join(`
+`);
+}
+function procDiagnosis(p) {
+  if (p.detail)
+    return p.detail;
+  if (p.status === "crashed")
+    return p.exitCode != null ? `It exited with code ${p.exitCode}.` : "It crashed.";
+  return "It never answered on that port.";
+}
 function ambientBlock(paragraphs) {
   const said = paragraphs.filter((p) => !!p);
   if (said.length === 0)
@@ -13906,6 +14322,9 @@ function previewContext(p) {
     case "setup":
       line = "Toyon is setting this worktree up and starts the preview when that is done; the next message will say where it answers.";
       break;
+    case "parked":
+      line = "The preview is off: Toyon has not started this worktree's dev servers, and starts them when you first write a file or when the user asks for them. Nothing answers until then.";
+      break;
     case "starting":
       line = `Toyon is starting the preview; it answers${at} once it is up.`;
       break;
@@ -13920,8 +14339,12 @@ function previewContext(p) {
   }
   return line;
 }
-function imageCaption(ref) {
-  return `${attachmentLabel("image", ref.n)}: ${ref.name} (${ref.width}\xD7${ref.height})`;
+function imageCaption(ref, path) {
+  return `${attachmentLabel("image", ref.n)}: ${ref.name} (${ref.width}\xD7${ref.height}), saved at ${path}`;
+}
+function fileCaption(ref, path, inline = false) {
+  const at = `A file the user attached: ${ref.name} (${fmtBytes(ref.bytes)}), saved at ${path}.`;
+  return inline ? at : `${at} Read or search it there.`;
 }
 function pasteCaption(ref) {
   const label = attachmentLabel("paste", ref.n);
@@ -13967,7 +14390,7 @@ function attachmentBlocks(a) {
   switch (a.kind) {
     case "image":
       return [
-        textBlock(imageCaption(a.ref)),
+        textBlock(imageCaption(a.ref, a.path)),
         { type: "image", mimeType: a.ref.mimeType, data: a.bytes.toString("base64") }
       ];
     case "paste":
@@ -13975,6 +14398,13 @@ function attachmentBlocks(a) {
 <pasted-text ${a.ref.n}>
 ${a.text}
 </pasted-text>`)];
+    case "file":
+      return [
+        textBlock(a.text === undefined ? fileCaption(a.ref, a.path) : `${fileCaption(a.ref, a.path, true)}
+<attached-file ${a.ref.n}>
+${a.text}
+</attached-file>`)
+      ];
     case "pick":
       return [textBlock(pickCaption(a.ref))];
   }
@@ -13983,9 +14413,9 @@ ${a.text}
 // ../daemon/src/agent/transcript.ts
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { appendFile } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function transcriptPathFor(transcriptsDir, worktreeId) {
-  return join6(transcriptsDir, `${worktreeId}.jsonl`);
+  return join7(transcriptsDir, `${worktreeId}.jsonl`);
 }
 function coalesce(entries) {
   const out = [];
@@ -14140,7 +14570,7 @@ async function cleanUp(ctx, a, sessionId) {
 import { existsSync as existsSync8, statSync as statSync3 } from "fs";
 import { open as open2 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { basename as basename2, dirname as dirname4, join as join7 } from "path";
+import { basename as basename2, dirname as dirname4, join as join8 } 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;
@@ -14153,14 +14583,14 @@ function spawnDetached(output) {
   return output.includes("Async agent launched successfully");
 }
 function claudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join7(homedir4(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || join8(homedir4(), ".claude");
 }
 function sessionLogFor(file, configDir = claudeConfigDir()) {
   const tasks = dirname4(file);
   if (basename2(tasks) !== "tasks")
     return null;
   const session = dirname4(tasks);
-  const path = join7(configDir, "projects", basename2(dirname4(session)), `${basename2(session)}.jsonl`);
+  const path = join8(configDir, "projects", basename2(dirname4(session)), `${basename2(session)}.jsonl`);
   return existsSync8(path) ? path : null;
 }
 function taskEnd(text, toolId) {
@@ -14521,11 +14951,32 @@ function endOfAsk(req, res, memos) {
     isError: !allowed
   };
 }
-function abandoned(memos, parent) {
+function release(toolId, memo) {
+  const held = memo.held;
+  if (!held)
+    return null;
+  delete memo.held;
+  if (!emptyInput(memo.input))
+    memo.writing = false;
+  return memo.ended ? null : { type: "tool-update", toolId, ...held };
+}
+function preempted(memos) {
+  for (const memo of memos.values()) {
+    if (!memo.ended && memo.writing && !memo.parent)
+      memo.cut = true;
+  }
+}
+function abandoned(memos, parent, opening = false) {
   const out = [];
   for (const [toolId, memo] of memos) {
     if (memo.ended || !memo.writing || memo.parent !== parent)
       continue;
+    if (opening && memo.held && !memo.cut) {
+      const sent = release(toolId, memo);
+      if (sent)
+        out.push(sent);
+      continue;
+    }
     memo.ended = true;
     out.push({ type: "tool-end", toolId });
   }
@@ -14554,7 +15005,7 @@ function mapUpdate(update, memos, tag, sink, background) {
     }
     case "tool_call": {
       const spawn = spawnOf(update._meta);
-      const out = abandoned(memos, spawn.parentToolId);
+      const out = abandoned(memos, spawn.parentToolId, true);
       const input = update.rawInput ?? { locations: update.locations ?? [] };
       const head = heading(update);
       const memo = {
@@ -14609,26 +15060,27 @@ function mapUpdate(update, memos, tag, sink, background) {
           ...spawn
         });
       }
-      if (update.rawInput !== undefined && update.content === undefined && update.status === undefined)
-        return out;
-      const refined = { type: "tool-update", toolId: update.toolCallId };
+      const refined = { ...memo.held };
       const title = memo.name === TOOL_SEARCH ? toolSearchQuery(update.rawInput) : update.title;
-      if (title && title !== memo.title) {
-        memo.title = title;
-        refined.title = title;
-      }
-      if (update.name && update.name !== memo.name) {
+      if (title && title !== memo.title)
+        refined.title = memo.title = title;
+      if (update.name && update.name !== memo.name)
         refined.name = memo.name = update.name;
-      }
       if (update.kind && update.kind !== memo.kind)
         refined.kind = memo.kind = update.kind;
-      if (update.rawInput !== undefined) {
+      if (update.rawInput !== undefined)
         refined.input = memo.input = update.rawInput;
-        if (!emptyInput(update.rawInput))
-          memo.writing = false;
+      if (update.rawInput !== undefined && update.content === undefined && update.status === undefined) {
+        if (out.length === 0)
+          memo.held = refined;
+        return out;
+      }
+      delete memo.held;
+      if (!emptyInput(memo.input))
+        memo.writing = false;
+      if (Object.keys(refined).length > 0 && !memo.ended && out.length === 0) {
+        out.push({ type: "tool-update", toolId: update.toolCallId, ...refined });
       }
-      if (Object.keys(refined).length > 2 && !memo.ended && out.length === 0)
-        out.push(refined);
       if (update.content)
         memo.content = [...memo.content, ...update.content];
       if (update.rawOutput !== undefined)
@@ -14776,6 +15228,11 @@ function steerOutcome(value) {
 // ../daemon/src/agent/acp/session.ts
 var DEFAULT_IDLE_MS = Number(process.env.TOYON_AGENT_IDLE_MS) || 5 * 60000;
 var OWN_SETTLE_MS = 1e4;
+var INPUT_HOLD_MS = 1000;
+var queued = (q) => ({
+  text: q.text,
+  ...q.attachments ? { attachments: q.attachments } : {}
+});
 function recorded(reply) {
   if (reply?.kind === "choice")
     return { choiceId: reply.choiceId };
@@ -14794,6 +15251,7 @@ class AcpSession {
   held = false;
   conn = null;
   connecting = null;
+  opening = null;
   live = null;
   reaper = null;
   own = null;
@@ -14891,7 +15349,7 @@ class AcpSession {
     return this.queue.length > 0 || this.steered.length > 0 || this.refused !== null || this.asks.size > 0;
   }
   get queueItems() {
-    return this.waiting().map((q) => q.text);
+    return this.waiting().map(queued);
   }
   waiting() {
     return this.queue.filter((q) => !q.recorded);
@@ -14900,13 +15358,19 @@ class AcpSession {
   queueChanged() {
     this.onQueueChange?.();
   }
-  unqueue(index) {
+  unqueue(index, taken) {
     const item = this.waiting()[index];
     if (!item)
       return;
     this.queue.splice(this.queue.indexOf(item), 1);
+    taken?.(queued(item));
+    this.letGo(item);
     this.queueChanged();
   }
+  letGo(item) {
+    if (!item.recorded)
+      this.d.attachments.uploads.release(uploadIds(item.attachments));
+  }
   transcript() {
     return this.log.entries;
   }
@@ -14924,8 +15388,19 @@ class AcpSession {
   send(text, opts = {}) {
     if (this.stopped)
       return log.warn(this.d.worktreeId, "send after close dropped");
-    const { context, attachments } = opts;
+    if (!opts.asked)
+      for (const ask of [...this.asks.values()])
+        ask.settle("skipped");
+    this.post(text, opts);
+  }
+  post(text, opts = {}) {
+    const { context, attachments, asked } = opts;
     const item = { text, context, ...attachments?.length ? { attachments } : {} };
+    if (asked) {
+      this.emit({ type: "fix-asked", text, ts: Date.now(), ...asked });
+      item.recorded = { attachments: [] };
+    }
+    this.d.attachments.uploads.hold(uploadIds(attachments));
     if ((this.running || this.own) && !this.interrupted && !this.held && this.live?.conn.steering) {
       return fireAndForget(this.d.worktreeId, this.steer(item), "agent steer");
     }
@@ -14980,7 +15455,10 @@ class AcpSession {
       }
       this.clearReaper();
       log.warn(this.d.worktreeId, "steered message started a turn of the agent's own");
+      return;
     }
+    if (this.live === live)
+      preempted(live.tools);
   }
   unsteer(item) {
     const at = this.steered.indexOf(item);
@@ -15012,6 +15490,8 @@ class AcpSession {
   async close() {
     this.stopped = true;
     this.clearReaper();
+    for (const item of this.queue)
+      this.letGo(item);
     this.queue = [];
     this.steered = [];
     this.queueChanged();
@@ -15135,8 +15615,8 @@ class AcpSession {
   retry() {
     const item = this.refused;
     this.refused = null;
-    if (item)
-      this.send(item.text, item);
+    if (item && !this.stopped)
+      this.enqueue(item);
   }
   planWithheld(conn, methodId) {
     return this.d.planSignIn?.() === false && conn.spec.terminalLogins?.[methodId]?.plan === true;
@@ -15159,8 +15639,12 @@ class AcpSession {
   }
   async record({ text, attachments }) {
     const stored = [];
-    for (const a of attachments ?? [])
-      stored.push(await this.d.attachments.put(this.d.worktreeId, this.seq[a.kind]++, a));
+    try {
+      for (const a of attachments ?? [])
+        stored.push(await this.d.attachments.put(this.d.worktreeId, this.seq[a.kind]++, a));
+    } finally {
+      this.d.attachments.uploads.release(uploadIds(attachments));
+    }
     this.emit({
       type: "user-message",
       text,
@@ -15182,6 +15666,11 @@ class AcpSession {
   }
   async runTurn(item) {
     item.recorded ??= await this.record(item);
+    try {
+      await this.d.beforeTurn?.();
+    } catch (e) {
+      log.warn(this.d.worktreeId, "before-turn hook failed", e);
+    }
     this.emit({ type: "turn-start", ts: Date.now() });
     const live = await this.ensureLive("a turn");
     await this.applyMode(live);
@@ -15273,8 +15762,18 @@ class AcpSession {
   }
   async ensureLive(why) {
     const conn = await this.ensureConn(why);
+    if (this.opening?.conn === conn)
+      return this.opening.live;
     if (this.live?.conn === conn)
       return this.live;
+    const live = this.openLive(conn).finally(() => {
+      if (this.opening?.live === live)
+        this.opening = null;
+    });
+    this.opening = { conn, live };
+    return live;
+  }
+  async openLive(conn) {
     const additionalDirectories = conn.bounds.gitDir ? [conn.bounds.gitDir] : [];
     let sessionId = this.d.getSessionId();
     let modes;
@@ -15315,7 +15814,7 @@ class AcpSession {
     this.emit({ type: "session-info", sessionId, ...currentValues(options) });
     this.learn(options);
     const modeOption = modes ? null : readModeOption(configOptions);
-    this.live = {
+    const live = {
       conn,
       sessionId,
       prefixPending: !resumed && conn.spec.systemPrompt === "prompt-prefix",
@@ -15325,13 +15824,14 @@ class AcpSession {
       modeConfigId: modeOption?.id ?? null,
       options
     };
-    await this.applyMode(this.live);
-    await this.applyOption(this.live, "model");
-    await this.applyOption(this.live, "thought_level");
+    this.live = live;
+    await this.applyMode(live);
+    await this.applyOption(live, "model");
+    await this.applyOption(live, "thought_level");
     const pushed = conn.commands.get(sessionId);
     if (pushed)
       this.setCommands(pushed);
-    return this.live;
+    return live;
   }
   mode() {
     return this.d.mode?.() ?? DEFAULT_PERMISSION_MODE;
@@ -15410,6 +15910,10 @@ class AcpSession {
     if (params.update.sessionUpdate === "config_option_update")
       this.absorb(live, params.update.configOptions);
     const events = mapUpdate(params.update, live.tools, this.d.worktreeId, (file, bytes) => fireAndForget(this.d.worktreeId, this.d.attachments.putToolImage(this.d.worktreeId, file, bytes), "tool image"), (toolId, start, input) => this.tasks.start(toolId, start, input));
+    this.forward(live, events);
+    this.holdInput(live, params.update);
+  }
+  forward(live, events) {
     if (!this.running)
       this.trackOwn(events);
     for (const ev of events) {
@@ -15418,6 +15922,23 @@ class AcpSession {
       this.emit(ev.type === "session-info" ? { ...ev, sessionId: live.sessionId } : ev);
     }
   }
+  holdInput(live, update) {
+    if (update.sessionUpdate !== "tool_call_update")
+      return;
+    const toolId = update.toolCallId;
+    const memo = live.tools.get(toolId);
+    const held = memo?.held;
+    if (!memo || !held)
+      return;
+    const t = setTimeout(() => {
+      if (this.live !== live || memo.held !== held || memo.cut || !(this.running || this.own))
+        return;
+      const sent = release(toolId, memo);
+      if (sent)
+        this.forward(live, [sent]);
+    }, this.d.inputHoldMs ?? INPUT_HOLD_MS);
+    t.unref?.();
+  }
   onPermission(params, bounds, sandboxed) {
     const tools = this.live?.tools;
     return Promise.resolve(this.answerPermission(params, bounds, sandboxed)).then((res) => {
@@ -15476,7 +15997,7 @@ class AcpSession {
   async sayPlanEdited(proposed, path) {
     if (!await this.d.planEdited?.(path, proposed))
       return;
-    this.send(`I edited the plan before approving it. Build what is in ${path}, not the plan you proposed.`);
+    this.post(`I edited the plan before approving it. Build what is in ${path}, not the plan you proposed.`);
   }
   onElicit(params, signal) {
     const live = this.live;
@@ -15671,9 +16192,9 @@ function sameCommands(a, b) {
 }
 
 // ../daemon/src/agent/planDoc.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
-var PLANS_DIR = join8(".toyon", "plans");
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
+var PLANS_DIR = join9(".toyon", "plans");
 var PLAN_NAME = /^(\d+)\.md$/;
 function isPlanPath(rel) {
   return rel.startsWith(`${PLANS_DIR}/`) && PLAN_NAME.test(rel.slice(PLANS_DIR.length + 1));
@@ -15682,7 +16203,7 @@ function nextNumber(dir) {
   if (!existsSync9(dir))
     return 1;
   let max = 0;
-  for (const name of readdirSync2(dir)) {
+  for (const name of readdirSync3(dir)) {
     const n = Number(PLAN_NAME.exec(name)?.[1]);
     if (n > max)
       max = n;
@@ -15690,11 +16211,11 @@ function nextNumber(dir) {
   return max + 1;
 }
 async function writePlanDoc(cwd, markdown) {
-  const dir = join8(cwd, PLANS_DIR);
-  const rel = join8(PLANS_DIR, `${nextNumber(dir)}.md`);
+  const dir = join9(cwd, PLANS_DIR);
+  const rel = join9(PLANS_DIR, `${nextNumber(dir)}.md`);
   try {
-    mkdirSync5(dir, { recursive: true });
-    writeFileSync4(join8(cwd, rel), markdown.endsWith(`
+    mkdirSync6(dir, { recursive: true });
+    writeFileSync4(join9(cwd, rel), markdown.endsWith(`
 `) ? markdown : `${markdown}
 `);
   } catch (e) {
@@ -15705,7 +16226,7 @@ async function writePlanDoc(cwd, markdown) {
   return rel;
 }
 function planEdited(cwd, rel, proposed) {
-  const file = join8(cwd, rel);
+  const file = join9(cwd, rel);
   if (!existsSync9(file))
     return false;
   try {
@@ -17010,11 +17531,12 @@ function defaultAgent(wt, d, preview, onProcess) {
     launch: (spec) => d.agents.command(spec),
     planSignIn: () => d.managed?.planSignIn ?? true,
     transcriptsDir: d.paths.transcriptsDir,
-    attachments: d.attachments ?? new AttachmentStore(d.paths.attachmentsDir),
+    attachments: d.attachments ?? new AttachmentStore(d.paths.attachmentsDir, new UploadStore(d.paths.uploadsDir)),
     getSessionId: () => d.state.session(wt.id),
     setSessionId: (id) => d.state.setSession(wt.id, id),
     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),
     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),
@@ -17159,6 +17681,18 @@ class RuntimeRegistry {
         return true;
     return false;
   }
+  demand() {
+    if (this.holds.size > 0)
+      return "working";
+    let waiting = false;
+    for (const rt of this.runtimes.values()) {
+      if (rt.agent.status === "working")
+        return "working";
+      if (rt.agent.status === "waiting")
+        waiting = true;
+    }
+    return waiting ? "waiting" : null;
+  }
   markSetup(id, on) {
     if (on)
       this.settingUp.add(id);
@@ -17318,9 +17852,12 @@ class RuntimeRegistry {
     return rt;
   }
   async start(wt, repo) {
-    if (!this.deps.state.worktree(wt.id))
+    const record = this.deps.state.worktree(wt.id);
+    if (!record)
       return;
     const rt = this.ensureAgent(wt);
+    if (record.parked)
+      return;
     const run = repo.needsSetup ? EMPTY_RUN : resolveRun(repo, wt);
     const leads = wt.kind !== "main" || !this.deps.mainLeads || this.deps.mainLeads(wt.repoId);
     if (rt.procs) {
@@ -17719,6 +18256,11 @@ class RuntimeRegistry {
     return rt?.procs ? previewTargetOf(rt.procs, rt.previewName) : null;
   }
   previewStanding(id) {
+    const wt = this.deps.state.worktree(id);
+    if (wt?.parked) {
+      const repo = this.deps.state.repos.find((r) => r.id === wt.repoId);
+      return repo && !repo.needsSetup && resolveRun(repo, wt).preview ? { status: "parked" } : null;
+    }
     if (this.settingUp.has(id))
       return { status: "setup" };
     const rt = this.runtimes.get(id);
@@ -17783,17 +18325,17 @@ class RuntimeRegistry {
 }
 
 // ../daemon/src/worktrees/naming.ts
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 import { existsSync as existsSync11 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function shortId() {
-  return randomBytes(5).toString("hex");
+  return randomBytes2(5).toString("hex");
 }
 function freeSlot(parent) {
   for (;; ) {
     const id = shortId();
     const dir = `wt-${id.slice(0, 4)}`;
-    if (!existsSync11(join9(parent, dir)))
+    if (!existsSync11(join10(parent, dir)))
       return { id, dir };
   }
 }
@@ -17827,18 +18369,20 @@ function clip(text, max = CLIP) {
   const line = text.replace(/\s+/g, " ").trim();
   return line.length > max ? `${line.slice(0, max - 1)}\u2026` : line;
 }
-function slice(asks, ts) {
-  return { asks, reply: "", edits: 0, toolErrors: 0, newestTs: ts };
+function slice(asks, fixes, ts) {
+  return { asks, fixes, reply: "", edits: 0, toolErrors: 0, newestTs: ts };
 }
 function turnsSince(entries, seenAt) {
   const turns = [];
   let pending = [];
+  let pendingFixes = [];
   let open = null;
   const writes = new Set;
   const refusals = new Map;
   const start = (ts) => {
-    const t = slice(pending, ts);
+    const t = slice(pending, pendingFixes, ts);
     pending = [];
+    pendingFixes = [];
     turns.push(t);
     return t;
   };
@@ -17846,12 +18390,16 @@ function turnsSince(entries, seenAt) {
     if (open && "ts" in e)
       open.newestTs = Math.max(open.newestTs, e.ts);
     switch (e.type) {
-      case "user-message":
-        if (open && open.stop === undefined && open.error === undefined && !open.auth)
-          open.asks.push(e.text);
-        else
-          pending.push(e.text);
+      case "user-message": {
+        const into = open && open.stop === undefined && open.error === undefined && !open.auth ? open : null;
+        (into?.asks ?? pending).push(e.text);
         break;
+      }
+      case "fix-asked": {
+        const into = open && open.stop === undefined && open.error === undefined && !open.auth ? open : null;
+        (into?.fixes ?? pendingFixes).push(e.why);
+        break;
+      }
       case "turn-start":
         open = start(e.ts);
         break;
@@ -18012,6 +18560,8 @@ function turnBlock(t) {
   const lines = [];
   if (t.asks.length)
     lines.push(`User asked: ${clip(t.asks.join(" / "), 400)}`);
+  if (t.fixes.length)
+    lines.push(`Toyon, not the user, asked for a fix: ${clip(t.fixes.join(" / "), 400)}`);
   if (t.reply.trim())
     lines.push(`Agent ended with: ${clip(t.reply, 1000)}`);
   return lines.join(`
@@ -18133,6 +18683,8 @@ function attachmentText(a) {
     return a.text;
   if (a.kind === "image")
     return a.name ? `image ${a.name}` : "an image";
+  if (a.kind === "file")
+    return `file ${a.name}`;
   return `element <${a.component ?? a.tag}>${a.text ? ` "${a.text}"` : ""}`;
 }
 function parseName(text) {
@@ -18207,29 +18759,29 @@ function makePlanner(agents) {
 }
 
 // ../daemon/src/core/assets.ts
-import { existsSync as existsSync12, readdirSync as readdirSync3, rmSync, statSync as statSync4 } from "fs";
-import { join as join10, resolve as resolve5 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, rmSync as rmSync2, statSync as statSync4 } from "fs";
+import { join as join11, resolve as resolve5 } from "path";
 function locateAssets(here, env = process.env) {
-  const packaged = existsSync12(join10(here, "shell", "index.html"));
+  const packaged = existsSync12(join11(here, "shell", "index.html"));
   return {
-    shellDist: env.TOYON_SHELL_DIST ?? (packaged ? join10(here, "shell") : join10(here, "../../shell/dist")),
-    bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join10(here, "bridge.js") : join10(here, "../../bridge/dist/bridge.js")),
+    shellDist: env.TOYON_SHELL_DIST ?? (packaged ? join11(here, "shell") : join11(here, "../../shell/dist")),
+    bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join11(here, "bridge.js") : join11(here, "../../bridge/dist/bridge.js")),
     sourceRoot: packaged ? null : resolve5(here, "../../.."),
-    packageJson: packaged ? join10(here, "..", "package.json") : null
+    packageJson: packaged ? join11(here, "..", "package.json") : null
   };
 }
 var KEEP_MS = 3 * 24 * 60 * 60 * 1000;
 function pruneAssets(shellDist) {
-  const dir = join10(shellDist, "assets");
+  const dir = join11(shellDist, "assets");
   let names;
   try {
-    names = readdirSync3(dir);
+    names = readdirSync4(dir);
   } catch {
     return 0;
   }
   const found = [];
   for (const name of names) {
-    const path = join10(dir, name);
+    const path = join11(dir, name);
     try {
       found.push({ path, mtime: statSync4(path).mtimeMs });
     } catch {}
@@ -18242,100 +18794,15 @@ function pruneAssets(shellDist) {
     if (newest - f.mtime <= KEEP_MS)
       continue;
     try {
-      rmSync(f.path, { recursive: true, force: true });
+      rmSync2(f.path, { recursive: true, force: true });
       gone++;
     } catch {}
   }
   return gone;
 }
 
-// ../daemon/src/core/dialog.ts
-import { existsSync as existsSync13 } from "fs";
-import { homedir as homedir5 } from "os";
-var PROMPTS = {
-  location: "Choose where the new project goes",
-  open: "Choose a project folder to open"
-};
-var SCRIPT = [
-  "on run argv",
-  "activate",
-  "POSIX path of (choose folder with prompt (item 1 of argv) default location (POSIX file (item 2 of argv)))",
-  "end run"
-];
-function folderDialog() {
-  let open = null;
-  let child = null;
-  let cancelled = false;
-  const ask = async (start, purpose) => {
-    const typed = start === "~" || start.startsWith("~/") ? `${homedir5()}${start.slice(1)}` : start;
-    const from = typed.startsWith("/") && existsSync13(typed) ? typed : homedir5();
-    cancelled = false;
-    const p = Bun.spawn(["osascript", ...SCRIPT.flatMap((line) => ["-e", line]), PROMPTS[purpose], from], {
-      stdout: "pipe",
-      stderr: "pipe",
-      stdin: "ignore"
-    });
-    child = p;
-    const [out, err, code] = await Promise.all([
-      new Response(p.stdout).text(),
-      new Response(p.stderr).text(),
-      p.exited
-    ]);
-    child = null;
-    if (code === 0)
-      return out.trim().replace(/\/+$/, "") || "/";
-    if (cancelled || err.includes("(-128)"))
-      return null;
-    throw new UserError(`the Finder dialog did not open: ${err.trim()}`);
-  };
-  return {
-    choose(start, purpose) {
-      if (process.platform !== "darwin") {
-        return Promise.reject(new UserError("choosing a folder in Finder is only available on macOS"));
-      }
-      if (!open) {
-        open = ask(start, purpose).finally(() => {
-          open = null;
-        });
-      }
-      return open;
-    },
-    cancel() {
-      if (!child)
-        return;
-      cancelled = true;
-      child.kill();
-    }
-  };
-}
-
-// ../daemon/src/core/hub.ts
-class Hub {
-  listeners = new Map;
-  on(event, fn) {
-    let set = this.listeners.get(event);
-    if (!set) {
-      set = new Set;
-      this.listeners.set(event, set);
-    }
-    set.add(fn);
-    return () => set?.delete(fn);
-  }
-  emit(event, ...args) {
-    const set = this.listeners.get(event);
-    if (!set)
-      return;
-    for (const fn of set) {
-      try {
-        const r = fn(...args);
-        if (r instanceof Promise)
-          r.catch((e) => log.error("hub", `async listener for ${String(event)} rejected`, e));
-      } catch (e) {
-        log.error("hub", `listener for ${String(event)} threw`, e);
-      }
-    }
-  }
-}
+// ../daemon/src/core/awake.ts
+import { spawn as spawn3 } from "child_process";
 
 // ../daemon/src/runtime/idle.ts
 var LOCAL_SLEEP_MS = 2 * 60 * 60000;
@@ -18643,21 +19110,223 @@ function humanMs(ms) {
   return `${Math.round(ms / 1000)} s`;
 }
 
-// ../daemon/src/core/idleExit.ts
-var STOP_AFTER_MS = 30 * 60000;
-function stopAfterFrom(raw, opts) {
-  if (raw === "off")
+// ../daemon/src/core/awake.ts
+var WAIT_MS = 30 * 60000;
+function idleSleepAssertion(raw, platform = process.platform) {
+  if (raw === "off" || platform !== "darwin")
     return null;
-  const n = Number(raw);
-  if (raw && Number.isFinite(n) && n > 0)
-    return n;
-  return opts.remote || opts.terminal || (opts.inCloud ?? cloud.enabled) ? null : STOP_AFTER_MS;
+  return () => {
+    const child = spawn3("/usr/bin/caffeinate", ["-i", "-w", String(process.pid)], { stdio: "ignore" });
+    child.on("error", (e) => log.warn("awake", "caffeinate did not start, so the Mac may sleep mid-turn", e));
+    child.unref();
+    return () => {
+      child.kill();
+    };
+  };
 }
 
-class IdleExit {
+class KeepAwake {
   d;
-  connected = 0;
-  quietAt;
+  release = null;
+  waitingAt = null;
+  remote = 0;
+  remoteLeftAt = null;
+  timer = null;
+  gone = false;
+  waitMs;
+  now;
+  constructor(d) {
+    this.d = d;
+    this.waitMs = d.waitMs ?? WAIT_MS;
+    this.now = d.now ?? Date.now;
+    d.hub.on("agentStatus", (_id, status) => {
+      if (status === "waiting")
+        this.waitingAt = this.now();
+      this.reconsider();
+    });
+    d.hub.on("holdsChanged", () => this.reconsider());
+    d.hub.on("keepAwakeChanged", () => this.reconsider());
+    this.reconsider();
+  }
+  setting() {
+    return this.d.assert ? this.d.mode() : null;
+  }
+  remoteShells(n) {
+    if (n === this.remote)
+      return;
+    if (n === 0)
+      this.remoteLeftAt = this.now();
+    this.remote = n;
+    this.reconsider();
+  }
+  stop() {
+    this.gone = true;
+    this.disarm();
+    this.hold(false);
+  }
+  reconsider() {
+    if (this.gone || !this.d.assert)
+      return;
+    this.disarm();
+    const mode = this.d.mode();
+    const demand = this.d.demand();
+    if (demand !== "waiting" || !this.d.answerable)
+      this.waitingAt = null;
+    else
+      this.waitingAt ??= this.now();
+    if (mode === "off") {
+      this.hold(false);
+      return;
+    }
+    if (mode === "always" || demand === "working" || this.remote > 0) {
+      this.hold(true);
+      return;
+    }
+    const since = Math.max(this.waitingAt ?? Number.NEGATIVE_INFINITY, this.remoteLeftAt ?? Number.NEGATIVE_INFINITY);
+    const left = since + this.waitMs - this.now();
+    if (left > 0) {
+      this.hold(true);
+      this.arm(left);
+      return;
+    }
+    if (this.release && Number.isFinite(since)) {
+      log.info("awake", `nobody has answered or connected for ${humanMs(this.waitMs)}; the machine may sleep again`);
+    }
+    this.hold(false);
+  }
+  hold(on) {
+    if (on === (this.release !== null))
+      return;
+    if (on) {
+      this.release = this.d.assert?.() ?? null;
+    } else {
+      this.release?.();
+      this.release = null;
+    }
+    log.debug("awake", on ? "holding off idle sleep" : "idle sleep allowed again");
+  }
+  arm(ms) {
+    const set = this.d.setTimer ?? ((fn, delay) => {
+      const t = setTimeout(fn, delay);
+      t.unref?.();
+      return t;
+    });
+    this.timer = set(() => {
+      this.timer = null;
+      this.reconsider();
+    }, ms);
+  }
+  disarm() {
+    if (!this.timer)
+      return;
+    (this.d.clearTimer ?? ((t) => clearTimeout(t)))(this.timer);
+    this.timer = null;
+  }
+}
+
+// ../daemon/src/core/dialog.ts
+import { existsSync as existsSync13 } from "fs";
+import { homedir as homedir5 } from "os";
+var PROMPTS = {
+  location: "Choose where the new project goes",
+  open: "Choose a project folder to open"
+};
+var SCRIPT = [
+  "on run argv",
+  "activate",
+  "POSIX path of (choose folder with prompt (item 1 of argv) default location (POSIX file (item 2 of argv)))",
+  "end run"
+];
+function folderDialog() {
+  let open = null;
+  let child = null;
+  let cancelled = false;
+  const ask = async (start, purpose) => {
+    const typed = start === "~" || start.startsWith("~/") ? `${homedir5()}${start.slice(1)}` : start;
+    const from = typed.startsWith("/") && existsSync13(typed) ? typed : homedir5();
+    cancelled = false;
+    const p = Bun.spawn(["osascript", ...SCRIPT.flatMap((line) => ["-e", line]), PROMPTS[purpose], from], {
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore"
+    });
+    child = p;
+    const [out, err, code] = await Promise.all([
+      new Response(p.stdout).text(),
+      new Response(p.stderr).text(),
+      p.exited
+    ]);
+    child = null;
+    if (code === 0)
+      return out.trim().replace(/\/+$/, "") || "/";
+    if (cancelled || err.includes("(-128)"))
+      return null;
+    throw new UserError(`the Finder dialog did not open: ${err.trim()}`);
+  };
+  return {
+    choose(start, purpose) {
+      if (process.platform !== "darwin") {
+        return Promise.reject(new UserError("choosing a folder in Finder is only available on macOS"));
+      }
+      if (!open) {
+        open = ask(start, purpose).finally(() => {
+          open = null;
+        });
+      }
+      return open;
+    },
+    cancel() {
+      if (!child)
+        return;
+      cancelled = true;
+      child.kill();
+    }
+  };
+}
+
+// ../daemon/src/core/hub.ts
+class Hub {
+  listeners = new Map;
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return () => set?.delete(fn);
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const fn of set) {
+      try {
+        const r = fn(...args);
+        if (r instanceof Promise)
+          r.catch((e) => log.error("hub", `async listener for ${String(event)} rejected`, e));
+      } catch (e) {
+        log.error("hub", `listener for ${String(event)} threw`, e);
+      }
+    }
+  }
+}
+
+// ../daemon/src/core/idleExit.ts
+var STOP_AFTER_MS = 30 * 60000;
+function stopAfterFrom(raw, opts) {
+  if (raw === "off")
+    return null;
+  const n = Number(raw);
+  if (raw && Number.isFinite(n) && n > 0)
+    return n;
+  return opts.remote || opts.terminal || (opts.inCloud ?? cloud.enabled) ? null : STOP_AFTER_MS;
+}
+
+class IdleExit {
+  d;
+  connected = 0;
+  quietAt;
   timer = null;
   gone = false;
   afterMs;
@@ -18732,7 +19401,7 @@ class IdleExit {
 }
 
 // ../daemon/src/core/restart.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { openSync } from "fs";
 import { homedir as homedir6 } from "os";
 function restartable(env = process.env) {
@@ -18753,7 +19422,7 @@ async function replacementRuns() {
 }
 function respawn(logFile) {
   const logFd = openSync(logFile, "a");
-  const child = spawn3(process.execPath, process.argv.slice(1), {
+  const child = spawn4(process.execPath, process.argv.slice(1), {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: { ...process.env }
@@ -18894,7 +19563,7 @@ class SelfWatch {
 }
 
 // ../daemon/src/core/state.ts
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 import { existsSync as existsSync14, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "fs";
 var GROUPS_SAVE_MS = 250;
 var SEEN_WORKTREES = 50;
@@ -18956,7 +19625,7 @@ function loadOrCreateToken(paths) {
   const TOKEN_FILE = paths.tokenFile;
   if (existsSync14(TOKEN_FILE))
     return readFileSync10(TOKEN_FILE, "utf8").trim();
-  const token = randomBytes2(32).toString("hex");
+  const token = randomBytes3(32).toString("hex");
   writeFileSync5(TOKEN_FILE, token, { mode: 384 });
   return token;
 }
@@ -19138,6 +19807,16 @@ class StateStore {
     delete this.state.defaultAgent;
     this.save();
   }
+  get keepAwake() {
+    return this.state.keepAwake ?? "use";
+  }
+  setKeepAwake(mode) {
+    if (mode === "use")
+      delete this.state.keepAwake;
+    else
+      this.state.keepAwake = mode;
+    this.save();
+  }
   get theme() {
     return this.state.theme;
   }
@@ -19170,7 +19849,7 @@ class StateStore {
 }
 
 // ../daemon/src/design/service.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // ../daemon/src/design/scan.ts
 var COLOR = /^(#|rgba?\(|hsla?\(|oklch\(|oklab\(|lab\(|lch\(|color\(|color-mix\(|light-dark\()/i;
@@ -19620,7 +20299,7 @@ class DesignService {
 async function readAll(root, paths) {
   const out = [];
   for (const path of paths) {
-    const file = Bun.file(join11(root, path));
+    const file = Bun.file(join12(root, path));
     if (file.size === 0 || file.size > MAX_FILE_BYTES)
       continue;
     try {
@@ -19735,7 +20414,7 @@ function typicalUse(classes) {
 var normal = (s) => s.replace(/[-_]/g, "").toLowerCase();
 async function loadProjectTypescript(root) {
   try {
-    return await import(join11(root, "node_modules", "typescript", "lib", "typescript.js"));
+    return await import(join12(root, "node_modules", "typescript", "lib", "typescript.js"));
   } catch {
     return null;
   }
@@ -19748,28 +20427,32 @@ var SAVE_DELAY_MS = 1000;
 class DraftStore {
   d;
   drafts = {};
+  lists = {};
+  dirty = { text: false, lists: false };
   saveTimer = null;
   constructor(d) {
     this.d = d;
-    if (!existsSync15(d.file))
-      return;
-    try {
-      const raw = JSON.parse(readFileSync11(d.file, "utf8"));
-      if (!raw || typeof raw !== "object")
-        return;
-      for (const [id, text] of Object.entries(raw)) {
-        if (typeof text === "string" && text)
-          this.drafts[id] = text;
-      }
-    } catch (e) {
-      log.warn("drafts", `skipped an unreadable ${d.file}`, e);
+    for (const [id, text] of readRecord(d.file)) {
+      if (typeof text === "string" && text)
+        this.drafts[id] = text;
+    }
+    for (const [id, list] of readRecord(d.attachmentsFile)) {
+      const items = (Array.isArray(list) ? list : []).flatMap((item) => {
+        const r = attachmentInputSchema.safeParse(item);
+        return r.success ? [r.data] : [];
+      });
+      if (items.length)
+        this.lists[id] = items;
     }
   }
   all() {
     return { ...this.drafts };
   }
+  allAttachments() {
+    return { ...this.lists };
+  }
   has(boxId) {
-    return !!this.drafts[boxId]?.trim();
+    return !!this.drafts[boxId]?.trim() || !!this.lists[boxId]?.length;
   }
   text(boxId) {
     return this.drafts[boxId] ?? "";
@@ -19781,22 +20464,67 @@ class DraftStore {
       this.drafts[boxId] = text;
     else
       delete this.drafts[boxId];
-    this.scheduleSave();
+    this.scheduleSave("text");
     this.d.hub.emit("draftChanged", boxId, text, clientId);
   }
+  attachments(boxId) {
+    return this.lists[boxId] ?? [];
+  }
+  setAttachments(boxId, items, clientId) {
+    if (JSON.stringify(this.lists[boxId] ?? []) === JSON.stringify(items))
+      return;
+    if (items.length)
+      this.lists[boxId] = items;
+    else
+      delete this.lists[boxId];
+    this.scheduleSave("lists");
+    this.d.uploads?.keep(this.uploadIds());
+    this.d.hub.emit("attachmentsChanged", boxId, items, clientId);
+  }
+  take(boxId, clientId) {
+    const was = { text: this.text(boxId), items: this.attachments(boxId) };
+    this.set(boxId, "", clientId);
+    this.setAttachments(boxId, [], clientId);
+    return was;
+  }
+  putBack(boxId, was, clientId) {
+    if (was.text && !this.text(boxId))
+      this.set(boxId, was.text, clientId);
+    if (was.items.length)
+      this.setAttachments(boxId, [...was.items, ...this.attachments(boxId)], clientId);
+  }
+  uploadIds() {
+    return Object.values(this.lists).flatMap((items) => uploadIds(items));
+  }
   drop(boxId) {
     this.set(boxId, "");
+    this.setAttachments(boxId, []);
+  }
+  move(fromId, toId, over = false) {
+    const text = this.text(fromId);
+    const items = this.attachments(fromId);
+    if (!text && !items.length)
+      return false;
+    if (!over && (this.text(toId) || this.attachments(toId).length))
+      return false;
+    this.set(toId, text);
+    this.setAttachments(toId, items);
+    this.drop(fromId);
+    return true;
   }
   prune(known) {
-    let changed = false;
     for (const id of Object.keys(this.drafts)) {
       if (known(id))
         continue;
       delete this.drafts[id];
-      changed = true;
+      this.scheduleSave("text");
+    }
+    for (const id of Object.keys(this.lists)) {
+      if (known(id))
+        continue;
+      delete this.lists[id];
+      this.scheduleSave("lists");
     }
-    if (changed)
-      this.scheduleSave();
   }
   flush() {
     if (!this.saveTimer)
@@ -19805,7 +20533,8 @@ class DraftStore {
     this.saveTimer = null;
     this.write();
   }
-  scheduleSave() {
+  scheduleSave(which) {
+    this.dirty[which] = true;
     if (this.saveTimer)
       return;
     this.saveTimer = setTimeout(() => {
@@ -19815,13 +20544,31 @@ class DraftStore {
     this.saveTimer.unref?.();
   }
   write() {
-    const tmp = `${this.d.file}.tmp`;
-    try {
-      writeFileSync6(tmp, JSON.stringify(this.drafts));
-      renameSync3(tmp, this.d.file);
-    } catch (e) {
-      log.error("drafts", "could not write the drafts", e);
-    }
+    if (this.dirty.text)
+      writeAtomic(this.d.file, this.drafts);
+    if (this.dirty.lists)
+      writeAtomic(this.d.attachmentsFile, this.lists);
+    this.dirty = { text: false, lists: false };
+  }
+}
+function readRecord(file) {
+  if (!existsSync15(file))
+    return [];
+  try {
+    const raw = JSON.parse(readFileSync11(file, "utf8"));
+    return raw && typeof raw === "object" ? Object.entries(raw) : [];
+  } catch (e) {
+    log.warn("drafts", `skipped an unreadable ${file}`, e);
+    return [];
+  }
+}
+function writeAtomic(file, value) {
+  const tmp = `${file}.tmp`;
+  try {
+    writeFileSync6(tmp, JSON.stringify(value));
+    renameSync3(tmp, file);
+  } catch (e) {
+    log.error("drafts", `could not write ${file}`, e);
   }
 }
 
@@ -19879,12 +20626,13 @@ class ExecService {
       if (opts.quiet)
         agent.note(start);
       agent.note({ type: "tool-end", toolId, output: `could not run: ${reason}`, isError: true });
-      return Promise.resolve({ exit: reason, text: "" });
+      return Promise.resolve({ exit: reason, text: "", toolId });
     }
     const pid = proc.pid;
     let killing;
     const running = {
       stop: () => {
+        running.stopping = true;
         killing ??= killGroup(pid, groupGone(pid)).then((signal) => {
           if (signal)
             running.signal = signal;
@@ -19901,7 +20649,8 @@ class ExecService {
     this.deps.runtime.hold(worktreeId, `exec:${toolId}`);
     this.deps.runtime.noteGroup(worktreeId, `exec:${toolId}`, pid);
     opts.onSpawn?.(pid, () => fireAndForget(worktreeId, running.stop(), `exec ${toolId} stopped`));
-    return this.collect(worktreeId, toolId, proc, running, agent, ceiling, opts.quiet ? start : undefined);
+    const kind = name === CHECK_TOOL ? "check" : "command";
+    return this.collect(worktreeId, toolId, proc, running, agent, ceiling, kind, opts.quiet ? start : undefined);
   }
   async watch(worktreeId, command, run) {
     const agent = this.agentFor(worktreeId);
@@ -19939,16 +20688,17 @@ class ExecService {
       this.untrack(worktreeId, toolId);
     }
     if (!up && r.exit === 0)
-      return { ...r, shown: false };
+      return { ...r, shown: false, toolId };
     if (!up)
       agent.note(start);
     agent.note({
       type: "tool-end",
       toolId,
       output: formatOutput(text, r.exit, truncated, r.ceilingMs),
-      isError: r.exit !== 0
+      isError: r.exit !== 0,
+      ...r.hook && typeof r.exit === "number" && r.exit !== 0 ? { fixable: { kind: "hook", hook: r.hook } } : {}
     });
-    return { ...r, shown: true };
+    return { ...r, shown: true, toolId };
   }
   async stop(worktreeId, toolId) {
     const byTool = this.running.get(worktreeId);
@@ -19981,7 +20731,7 @@ class ExecService {
     this.deps.runtime.release(worktreeId, `exec:${toolId}`);
     this.deps.runtime.forgetGroup(worktreeId, pgid);
   }
-  async collect(worktreeId, toolId, proc, running, agent, ceiling, heldStart) {
+  async collect(worktreeId, toolId, proc, running, agent, ceiling, kind, heldStart) {
     let text = "";
     let truncated = false;
     const live = !heldStart;
@@ -20019,7 +20769,13 @@ class ExecService {
       log.warn(worktreeId, "exec: reading output failed", e);
     }
     const pgid = proc.pid;
-    const end = (how) => agent.note({ type: "tool-end", toolId, output: formatOutput(text, how, truncated, ceiling), isError: how !== 0 });
+    const end = (how) => agent.note({
+      type: "tool-end",
+      toolId,
+      output: formatOutput(text, how, truncated, ceiling),
+      isError: how !== 0,
+      ...typeof how === "number" && how !== 0 && !running.stopping && !running.timedOut ? { fixable: { kind } } : {}
+    });
     const lingers = running.signal === undefined && groupAlive(pgid);
     if (!lingers)
       this.settle(worktreeId, toolId, pgid);
@@ -20030,18 +20786,18 @@ class ExecService {
       }
       if (lingers)
         fireAndForget(worktreeId, this.linger(running, pgid).then(() => this.settle(worktreeId, toolId, pgid)), `exec ${toolId} left running`);
-      return { exit: running.timedOut ? "timeout" : exit, text };
+      return { exit: running.timedOut ? "timeout" : exit, text, toolId };
     }
     if (!lingers) {
       end(running.timedOut ? "timeout" : exit);
-      return { exit: running.timedOut ? "timeout" : exit, text };
+      return { exit: running.timedOut ? "timeout" : exit, text, toolId };
     }
     agent.note({ type: "tool-update", toolId, background: true });
     fireAndForget(worktreeId, this.linger(running, pgid).then(() => {
       this.settle(worktreeId, toolId, pgid);
       end(running.timedOut ? "timeout" : running.signal ?? exit);
     }), `exec ${toolId} in the background`);
-    return { exit, text };
+    return { exit, text, toolId };
   }
   async linger(running, pgid) {
     while (running.signal === undefined && groupAlive(pgid))
@@ -20050,17 +20806,17 @@ class ExecService {
 }
 
 // ../daemon/src/files/open.ts
-import { stat as stat2 } from "fs/promises";
+import { stat as stat3 } from "fs/promises";
 import { basename as basename3, resolve as resolve7 } from "path";
 
 // ../daemon/src/repos/browse.ts
 import { existsSync as existsSync16, statSync as statSync5 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname5, join as join12 } from "path";
+import { dirname as dirname5, join as join13 } from "path";
 var MAX_ENTRIES = 40;
 function expandTilde(raw) {
-  return raw === "~" || raw.startsWith("~/") ? join12(homedir7(), raw.slice(1)) : raw;
+  return raw === "~" || raw.startsWith("~/") ? join13(homedir7(), raw.slice(1)) : raw;
 }
 function collapseTilde(abs) {
   const home = homedir7();
@@ -20071,7 +20827,7 @@ function holdsNothing(names) {
 }
 async function describeFolder(abs) {
   const path = collapseTilde(abs);
-  if (existsSync16(join12(abs, ".git")))
+  if (existsSync16(join13(abs, ".git")))
     return { path, kind: "project" };
   try {
     return { path, kind: holdsNothing(await readdir(abs)) ? "empty" : "folder" };
@@ -20088,7 +20844,7 @@ function describe2(typed, parent) {
   return {
     exists: existsSync16(typed),
     isDir,
-    isRepo: isDir && existsSync16(join12(typed, ".git")),
+    isRepo: isDir && existsSync16(join13(typed, ".git")),
     parentExists: existsSync16(parent)
   };
 }
@@ -20113,8 +20869,8 @@ async function browsePath(raw) {
       continue;
     if (!name.toLowerCase().startsWith(prefix))
       continue;
-    const abs = join12(dir, name);
-    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync16(join12(abs, ".git")) });
+    const abs = join13(dir, name);
+    entries.push({ path: collapseTilde(abs), name, isRepo: existsSync16(join13(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 };
@@ -20150,8 +20906,8 @@ function looksBinary(text) {
 }
 
 // ../daemon/src/files/service.ts
-import { spawn as spawn4 } from "child_process";
-import { stat, unlink } from "fs/promises";
+import { spawn as spawn5 } from "child_process";
+import { stat as stat2, unlink } from "fs/promises";
 
 // ../daemon/src/git/blame.ts
 var NONE = { commits: [], lines: [] };
@@ -20222,10 +20978,13 @@ async function withLock(key, fn) {
 function withRepoLock(repoPath, fn) {
   return withLock(repoPath, fn);
 }
+function withFetchLock(repoPath, fn) {
+  return withLock(`fetch:${repoPath}`, fn);
+}
 var fileLockKey = (absPath) => `file:${absPath}`;
 
 // ../daemon/src/git/status.ts
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function treeFingerprint(worktreePath) {
   const [head, diff, untracked] = await Promise.all([
     git(worktreePath, "rev-parse", "HEAD"),
@@ -20235,7 +20994,7 @@ async function treeFingerprint(worktreePath) {
   const others = await Promise.all(untracked.out.split(`
 `).filter(Boolean).map(async (p) => {
     try {
-      const f = Bun.file(join13(worktreePath, p));
+      const f = Bun.file(join14(worktreePath, p));
       const body = f.size > 2000000 ? String(f.size) : Bun.hash(await f.arrayBuffer()).toString(36);
       return `${p}:${body}`;
     } catch {
@@ -20268,6 +21027,10 @@ async function fileBefore(worktreePath, defaultBr, file) {
   const r = await gitRaw(worktreePath, "show", `${ref}:${file}`);
   return r.ok ? r.out : "";
 }
+async function fileAt(worktreePath, commit, file) {
+  const r = await gitRaw(worktreePath, "show", `${commit}:${file}`);
+  return r.ok ? r.out : "";
+}
 function parseNumstat(out) {
   const counts = new Map;
   for (const line of out.split(`
@@ -20286,7 +21049,7 @@ async function numstat(worktreePath, ...range) {
 }
 async function untrackedLines(worktreePath, file) {
   try {
-    const f = Bun.file(join13(worktreePath, file));
+    const f = Bun.file(join14(worktreePath, file));
     if (f.size > 2000000)
       return {};
     const buf = new Uint8Array(await f.arrayBuffer());
@@ -20459,7 +21222,7 @@ var COMMON = 40;
 var NEAR = 3;
 var CLEAR_LEAD = 1.5;
 var ELEMENT_SOURCES_MAX = 8;
-var NAME = /^[\w-]+$/;
+var NAME2 = /^[\w-]+$/;
 var TAG = /^[a-z][a-z0-9-]*$/;
 var NAME_CHAR = /[\w-]/;
 function needlesOf(el) {
@@ -20472,12 +21235,12 @@ function needlesOf(el) {
       out.set(text, { text, weight, word });
   };
   if (el.id)
-    add(el.id, 8, NAME.test(el.id));
+    add(el.id, 8, NAME2.test(el.id));
   const words = (el.text.split(/[&<>"'`${}]/)[0] ?? "").trim().split(/\s+/).slice(0, 6).join(" ");
   if (words.length >= 3 && /\p{L}/u.test(words))
     add(words, 6, false);
   for (const [, value] of el.attrs)
-    add(value, 5, NAME.test(value));
+    add(value, 5, NAME2.test(value));
   for (const c of el.classes)
     add(c, 3, true);
   return [...out.values()];
@@ -20643,7 +21406,7 @@ var NOT_WHERE_WRITTEN = [
 ];
 var NO_TEXT = { before: "", after: "" };
 async function statFile(target) {
-  const st = await stat(target).catch((e) => {
+  const st = await stat2(target).catch((e) => {
     if (e.code === "ENOENT")
       return null;
     throw e;
@@ -20704,14 +21467,14 @@ class FileService {
       throw new UserError("unknown worktree");
     return r;
   }
-  async read(worktreeId, path, ref) {
+  async read(worktreeId, path, ref, since) {
     const r = this.require(worktreeId);
     const target = resolveInside(r.path, path);
     if (ref) {
       const { before, after } = await fileAtCommit(r.path, ref, path);
       return { ...sides(before, after), version: null, writable: false };
     }
-    const before = await fileBefore(r.path, r.base, path);
+    const before = since ? await fileAt(r.path, since, path) : await fileBefore(r.path, r.base, path);
     const st = await statFile(target);
     if (st && st.size > FILE_MAX_CHARS) {
       return { ...NO_TEXT, version: `${st.size}-${st.mtimeMs}`, writable: false, binary: false, tooLarge: true };
@@ -20842,7 +21605,7 @@ class FileService {
   revealPath(target) {
     if (process.platform !== "darwin")
       throw new UserError("reveal is only available on macOS");
-    const child = spawn4("open", ["-R", target], { stdio: "ignore" });
+    const child = spawn5("open", ["-R", target], { stdio: "ignore" });
     child.on("error", () => {});
     child.unref();
   }
@@ -20890,7 +21653,7 @@ class OpenService {
   }
   async locate(raw) {
     const path = canonical(resolve7(expandTilde(raw)));
-    const st = await stat2(path).catch((e) => {
+    const st = await stat3(path).catch((e) => {
       if (e.code === "ENOENT")
         return null;
       throw e;
@@ -21169,9 +21932,9 @@ class AfterLand {
 }
 
 // ../daemon/src/repos/registry.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync6, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync7, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir9 } from "os";
-import { basename as basename5, dirname as dirname7, join as join17 } from "path";
+import { basename as basename5, dirname as dirname7, join as join18 } from "path";
 
 // ../daemon/src/git/base.ts
 async function resolveBase(repoPath, defaultBranch, route) {
@@ -21182,8 +21945,8 @@ async function resolveBase(repoPath, defaultBranch, route) {
 }
 
 // ../daemon/src/repos/config.ts
-import { closeSync, existsSync as existsSync17, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync12, readSync, statSync as statSync6 } from "fs";
-import { join as join14 } from "path";
+import { closeSync, existsSync as existsSync17, openSync as openSync2, readdirSync as readdirSync5, readFileSync as readFileSync12, readSync, statSync as statSync6 } from "fs";
+import { join as join15 } from "path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -22547,7 +23310,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) => existsSync17(join14(repoPath, rel)));
+var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync17(join15(repoPath, rel)));
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function parseSettings(text) {
   const errors = [];
@@ -22572,7 +23335,7 @@ function readConfigFile(repoPath) {
   for (const rel of files) {
     let raw;
     try {
-      raw = parseSettings(readFileSync12(join14(repoPath, rel), "utf8"));
+      raw = parseSettings(readFileSync12(join15(repoPath, rel), "utf8"));
     } catch (e) {
       return { ok: false, reason: `${rel} is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
     }
@@ -22631,7 +23394,7 @@ function configTarget(repoPath, made) {
 }
 function configBody(repoPath, rel, config) {
   const place = PLACES.find((p) => p.local === rel);
-  const abs = place && join14(repoPath, place.shared);
+  const abs = place && join15(repoPath, place.shared);
   if (!abs || !existsSync17(abs))
     return config;
   let shared;
@@ -22649,7 +23412,7 @@ function configText(repoPath, rel, config) {
   let text;
   let was;
   try {
-    text = readFileSync12(join14(repoPath, rel), "utf8");
+    text = readFileSync12(join15(repoPath, rel), "utf8");
     was = parseSettings(text);
   } catch {
     return fresh;
@@ -22679,7 +23442,7 @@ function detectConfig(repoPath) {
     return { config: explicit.config, needsSetup: false };
   if (explicit)
     log.warn("config", `${repoPath}: ${explicit.reason}; detecting instead`);
-  const pkgPath = join14(repoPath, "package.json");
+  const pkgPath = join15(repoPath, "package.json");
   if (existsSync17(pkgPath)) {
     const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
@@ -22702,7 +23465,7 @@ function detectConfig(repoPath) {
       };
     }
   }
-  if (existsSync17(join14(repoPath, "start.sh"))) {
+  if (existsSync17(join15(repoPath, "start.sh"))) {
     return { config: { run: { app: "./start.sh" } }, needsSetup: true, from: "start.sh" };
   }
   const assumed = assumeNothingToRun(repoPath);
@@ -22745,24 +23508,24 @@ function assumeNothingToRun(repoPath) {
   return marker && !servesPage(repoPath) ? marker : undefined;
 }
 function markerIn(repoPath) {
-  const named = NO_PAGE_MARKERS.find((f) => existsSync17(join14(repoPath, f)));
+  const named = NO_PAGE_MARKERS.find((f) => existsSync17(join15(repoPath, f)));
   if (named)
     return named;
   let entries;
   try {
-    entries = readdirSync4(repoPath);
+    entries = readdirSync5(repoPath);
   } catch {
     return;
   }
   return entries.find((f) => NO_PAGE_EXTENSIONS.some((ext) => f.endsWith(ext)));
 }
 function servesPage(repoPath) {
-  if (WEB_FILES.some((f) => existsSync17(join14(repoPath, f))))
+  if (WEB_FILES.some((f) => existsSync17(join15(repoPath, f))))
     return true;
-  if (/^web:/m.test(head(join14(repoPath, "Procfile"))))
+  if (/^web:/m.test(head(join15(repoPath, "Procfile"))))
     return true;
   for (const [files, names] of WEB_DEPENDENCIES) {
-    const text = files.map((f) => head(join14(repoPath, f))).join(`
+    const text = files.map((f) => head(join15(repoPath, f))).join(`
 `);
     if (text.trim() && names.some((n) => mentions(text, n)))
       return true;
@@ -22772,14 +23535,14 @@ function servesPage(repoPath) {
 function frontEndBeside(repoPath) {
   let dirs;
   try {
-    dirs = readdirSync4(repoPath, { withFileTypes: true });
+    dirs = readdirSync5(repoPath, { withFileTypes: true });
   } catch {
     return false;
   }
   return dirs.some((d) => {
     if (!d.isDirectory() || d.name.startsWith(".") || NOT_A_PACKAGE.has(d.name))
       return false;
-    const pkg = head(join14(repoPath, d.name, "package.json"));
+    const pkg = head(join15(repoPath, d.name, "package.json"));
     if (!pkg)
       return false;
     try {
@@ -22835,11 +23598,11 @@ function isLocalDatabase(url) {
 }
 function detectServices(repoPath) {
   const out = {};
-  const compose = COMPOSE_FILES.find((f) => existsSync17(join14(repoPath, f)));
+  const compose = COMPOSE_FILES.find((f) => existsSync17(join15(repoPath, f)));
   if (compose)
     out.compose = compose;
   for (const file of ENV_FILES) {
-    const text = head(join14(repoPath, file));
+    const text = head(join15(repoPath, file));
     if (!text)
       continue;
     for (const name of DB_URL_NAMES) {
@@ -22863,7 +23626,7 @@ function inferPaths(cmd, repoPath, depth = 1) {
       return;
     let dir = false;
     try {
-      dir = statSync6(join14(repoPath, clean)).isDirectory();
+      dir = statSync6(join15(repoPath, clean)).isDirectory();
     } catch {
       return;
     }
@@ -22874,25 +23637,25 @@ function inferPaths(cmd, repoPath, depth = 1) {
     const t = tokens[i];
     if (t === "cd") {
       const dir = tokens[i + 1];
-      if (dir && !dir.startsWith("-") && existsSync17(join14(repoPath, dir)))
+      if (dir && !dir.startsWith("-") && existsSync17(join15(repoPath, dir)))
         add(dir);
       continue;
     }
     if (t.startsWith("-") || t.startsWith("$"))
       continue;
     const mod = /^([A-Za-z_]\w*)(?:\.\w+)*:\w+$/.exec(t);
-    if (mod?.[1] && existsSync17(join14(repoPath, mod[1]))) {
+    if (mod?.[1] && existsSync17(join15(repoPath, mod[1]))) {
       add(mod[1]);
       continue;
     }
     const rel = t.replace(/^\.\//, "");
     if (rel.startsWith("/") || rel.startsWith("..") || rel.includes("="))
       continue;
-    if (!existsSync17(join14(repoPath, rel)))
+    if (!existsSync17(join15(repoPath, rel)))
       continue;
     add(rel);
     if (depth > 0 && rel.endsWith(".sh")) {
-      for (const p of inferPaths(head(join14(repoPath, rel)), repoPath, depth - 1))
+      for (const p of inferPaths(head(join15(repoPath, rel)), repoPath, depth - 1))
         out.add(p);
     }
   }
@@ -22915,9 +23678,9 @@ function procCommand(runner, script, body) {
   return `${base}${runner === "npm" ? " --" : ""} ${flag}`;
 }
 function detectPages(repoPath, scripts, runner) {
-  if (!scripts.build || !existsSync17(join14(repoPath, "functions")))
+  if (!scripts.build || !existsSync17(join15(repoPath, "functions")))
     return null;
-  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join14(repoPath, f)).find((f) => existsSync17(f));
+  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join15(repoPath, f)).find((f) => existsSync17(f));
   if (!cfg)
     return null;
   const out = readFileSync12(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
@@ -22926,20 +23689,20 @@ 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 (existsSync17(join14(repoPath, "bun.lock")) || existsSync17(join14(repoPath, "bun.lockb")))
+  if (existsSync17(join15(repoPath, "bun.lock")) || existsSync17(join15(repoPath, "bun.lockb")))
     return "bun";
-  if (existsSync17(join14(repoPath, "pnpm-lock.yaml")))
+  if (existsSync17(join15(repoPath, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync17(join14(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
+  if (existsSync17(join15(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
     return "yarn";
   return "npm";
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync18, readdirSync as readdirSync5, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync6, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
 import { appendFile as appendFile2, mkdir as mkdir2, rm } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname6, join as join15, resolve as resolve8 } from "path";
+import { dirname as dirname6, join as join16, resolve as resolve8 } from "path";
 function isInside(dir, parent) {
   const p = parent.replace(/\/+$/, "");
   return dir === p || dir.startsWith(`${p}/`);
@@ -22950,29 +23713,29 @@ function planProject(opts, home = homedir8()) {
     throw new UserError(nameError);
   const first = firstProjectsFolder(opts.parent, home);
   const parent = first ?? resolveParent(opts.parent);
-  const dir = join15(parent, opts.name.trim());
+  const dir = join16(parent, opts.name.trim());
   if (existsSync18(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 !== join15(home, PROJECTS_FOLDER) || existsSync18(typed) || !existsSync18(home))
+  if (typed !== join16(home, PROJECTS_FOLDER) || existsSync18(typed) || !existsSync18(home))
     return null;
-  return join15(realpathSync2(home), PROJECTS_FOLDER);
+  return join16(realpathSync2(home), PROJECTS_FOLDER);
 }
 function planInPlace(opts) {
   const name = opts.name.trim();
   if (!name || name === "." || name === ".." || name.includes("/")) {
     throw new UserError(`${opts.name} is not a folder name`);
   }
-  const typed = join15(resolveParent(opts.parent), name);
+  const typed = join16(resolveParent(opts.parent), name);
   if (!existsSync18(typed) || !statSync7(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
-  if (existsSync18(join15(dir, ".git")))
+  if (existsSync18(join16(dir, ".git")))
     throw new UserError(`${dir} is already a project; open it instead`);
-  if (!holdsNothing(readdirSync5(dir))) {
+  if (!holdsNothing(readdirSync6(dir))) {
     throw new UserError(`${dir} is not empty; only an empty folder can become a project where it is`);
   }
   return { parent: dirname6(dir), dir, makeParent: false };
@@ -23061,13 +23824,13 @@ async function undoCreate(dir) {
 }
 async function undoInit(dir) {
   try {
-    await rm(join15(dir, ".git"), { recursive: true, force: true });
+    await rm(join16(dir, ".git"), { recursive: true, force: true });
   } catch (e) {
     log.warn(dir, "could not take back a half-made .git", e);
   }
 }
 async function unmakeProject(dir, made) {
-  const target = made === "folder" ? dir : join15(dir, ".git");
+  const target = made === "folder" ? dir : join16(dir, ".git");
   try {
     await rm(target, { recursive: true, force: true });
   } catch (e) {
@@ -23098,7 +23861,7 @@ async function ok(p, what) {
 
 // ../daemon/src/repos/watcher.ts
 import { existsSync as existsSync19, watch } from "fs";
-import { basename as basename4, join as join16 } from "path";
+import { basename as basename4, join as join17 } from "path";
 function watchDefaultBranch(repoPath, branch, onMove) {
   const last = { local: null, upstream: null };
   const read = async () => {
@@ -23151,13 +23914,13 @@ function watchDefaultBranch(repoPath, branch, onMove) {
     ]);
     if (stopped)
       return;
-    const gitDir = common.ok && common.out ? common.out : join16(repoPath, ".git");
+    const gitDir = common.ok && common.out ? common.out : join17(repoPath, ".git");
     tryWatch(gitDir);
-    tryWatch(join16(gitDir, "refs", "heads"));
+    tryWatch(join17(gitDir, "refs", "heads"));
     if (!remote.ok || !remote.out)
       return;
-    const remotes = join16(gitDir, "refs", "remotes");
-    const mine = join16(remotes, remote.out);
+    const remotes = join17(gitDir, "refs", "remotes");
+    const mine = join17(remotes, remote.out);
     let inner = null;
     let mid = null;
     const armInner = () => {
@@ -23173,7 +23936,7 @@ function watchDefaultBranch(repoPath, branch, onMove) {
       }) : null;
       armInner();
     };
-    tryWatch(join16(gitDir, "refs"), (_event, filename) => {
+    tryWatch(join17(gitDir, "refs"), (_event, filename) => {
       if (!filename || filename === "remotes")
         armMid();
       schedule();
@@ -23202,7 +23965,7 @@ function watchWorktreeDir(repoPath, onChange) {
     }, 300);
   };
   const arm = (commonDir) => {
-    const dir = join16(commonDir, "worktrees");
+    const dir = join17(commonDir, "worktrees");
     const armInner = () => {
       inner?.close();
       inner = null;
@@ -23245,7 +24008,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) => basename4(rel)));
-  const dir = join16(repoPath, CONFIG_DIR);
+  const dir = join17(repoPath, CONFIG_DIR);
   let timer = null;
   let outer = null;
   let inner = null;
@@ -23382,7 +24145,7 @@ class RepoRegistry {
       return `${repo.name} is set up now`;
     if (main.promptedAt || main.lastTurn)
       return `${repo.name} has a chat now`;
-    if (existsSync20(join17(repo.path, ".claude")))
+    if (existsSync20(join18(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`;
@@ -23533,10 +24296,10 @@ class RepoRegistry {
       throw new UserError(current.reason);
     const was = configTarget(repo.path, !!repo.made);
     const rel = configSibling(was, kind);
-    const moved = rel !== was && existsSync20(join17(repo.path, was));
+    const moved = rel !== was && existsSync20(join18(repo.path, was));
     if (moved && !(kind === "local" && await isTracked(repo.path, was))) {
       try {
-        rmSync2(join17(repo.path, was));
+        rmSync3(join18(repo.path, was));
       } catch (e) {
         log.warn(repoId, `could not remove ${was}`, e);
       }
@@ -23545,9 +24308,9 @@ class RepoRegistry {
     }
     if (isLocalConfigFile(rel))
       await excludeFromGit(repo.path, rel);
-    const file = join17(repo.path, rel);
+    const file = join18(repo.path, rel);
     try {
-      mkdirSync6(dirname7(file), { recursive: true });
+      mkdirSync7(dirname7(file), { recursive: true });
       writeFileSync7(file, configText(repo.path, rel, config));
     } catch (e) {
       log.warn(repoId, `could not write ${rel}`, e);
@@ -23649,7 +24412,7 @@ class RepoRegistry {
   }
   placeConfig(repo) {
     const rel = configTarget(repo.path, !!repo.made);
-    if (isLocalConfigFile(rel) && existsSync20(join17(repo.path, rel))) {
+    if (isLocalConfigFile(rel) && existsSync20(join18(repo.path, rel))) {
       fireAndForget(repo.id, excludeFromGit(repo.path, rel), "exclude local settings");
     }
     if (repo.configFile === rel)
@@ -23741,7 +24504,7 @@ class RepoRegistry {
 }
 
 // ../daemon/src/routes/service.ts
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // ../daemon/src/routes/fileRouters.ts
 var SKIP = /(^|\/)(node_modules|dist|build|out|coverage|\.next|\.nuxt|\.output|\.svelte-kit|\.vercel|\.netlify)\//;
@@ -24941,7 +25704,7 @@ class RouteService {
     return mergeRoutes(fileRoutes(paths, roots), code);
   }
   async cachedRead(root, path, had, kept, decode) {
-    const abs = join18(root, path);
+    const abs = join19(root, path);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -24966,7 +25729,7 @@ class RouteService {
     }
   }
   async hash(root, file) {
-    const abs = join18(root, file);
+    const abs = join19(root, file);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -25288,7 +26051,7 @@ function servedLocally(origin) {
 import { homedir as homedir11 } from "os";
 
 // ../daemon/src/core/pair.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 class PairCodes {
   now;
   live = null;
@@ -25296,7 +26059,7 @@ class PairCodes {
     this.now = now;
   }
   mint() {
-    const code = randomBytes3(9).toString("base64url");
+    const code = randomBytes4(9).toString("base64url");
     this.live = { code, until: this.now() + PAIR_TTL_MS };
     return { code, ms: PAIR_TTL_MS };
   }
@@ -25307,10 +26070,56 @@ class PairCodes {
   }
 }
 
+// ../daemon/src/core/tailnet.ts
+var PHONE_OS = new Set(["android", "ios"]);
+function tailnetPhones(json) {
+  let st;
+  try {
+    st = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (st === null || typeof st !== "object")
+    return null;
+  const phones = [];
+  for (const p of Object.values(st.Peer ?? {})) {
+    if (!p || !PHONE_OS.has((p.OS ?? "").toLowerCase()))
+      continue;
+    const name = p.HostName || (p.DNSName ?? "").split(".")[0] || "a phone";
+    phones.push({ name, ip: p.TailscaleIPs?.[0] ?? null });
+  }
+  return phones;
+}
+var PING_TIMEOUT = "2s";
+function cli(bin) {
+  return async (args) => {
+    try {
+      const p = Bun.spawn([bin, ...args], { stdin: "ignore", stdout: "pipe", stderr: "ignore", timeout: 5000 });
+      const out = await new Response(p.stdout).text();
+      return { ok: await p.exited === 0, out };
+    } catch {
+      return { ok: false, out: "" };
+    }
+  };
+}
+var ping = (ip) => ["ping", "--until-direct=false", "--c", "1", "--timeout", PING_TIMEOUT, ip];
+async function readTailnetPhones(run = ((bin) => bin ? cli(bin) : null)(Bun.which("tailscale"))) {
+  if (run === null)
+    return null;
+  const st = await run(["status", "--json"]);
+  const listed = st.ok ? tailnetPhones(st.out) : null;
+  if (listed === null)
+    return null;
+  return Promise.all(listed.map(async ({ name, ip }) => ({ name, online: ip !== null && (await run(ping(ip))).ok })));
+}
+
+// ../daemon/src/server/handlers.ts
+import { randomBytes as randomBytes5 } from "crypto";
+
 // ../daemon/src/agent/config.ts
 import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function agentConfigFiles(spec, repoPath, home = homedir10()) {
   const file = (id, label, path) => ({
     id,
@@ -25320,30 +26129,30 @@ function agentConfigFiles(spec, repoPath, home = homedir10()) {
   });
   if (spec.id === "claude") {
     return [
-      file("user-config", "user config (MCP servers, projects)", join19(home, ".claude.json")),
-      file("user-settings", "user settings (permissions, hooks)", join19(home, ".claude", "settings.json")),
-      ...repoPath ? [file("project-mcp", "project MCP servers", join19(repoPath, ".mcp.json"))] : [],
-      ...repoPath ? [file("project-settings", "project settings", join19(repoPath, ".claude", "settings.json"))] : []
+      file("user-config", "user config (MCP servers, projects)", join20(home, ".claude.json")),
+      file("user-settings", "user settings (permissions, hooks)", join20(home, ".claude", "settings.json")),
+      ...repoPath ? [file("project-mcp", "project MCP servers", join20(repoPath, ".mcp.json"))] : [],
+      ...repoPath ? [file("project-settings", "project settings", join20(repoPath, ".claude", "settings.json"))] : []
     ];
   }
   if (spec.id === "codex")
-    return [file("user-config", "config", join19(home, ".codex", "config.toml"))];
+    return [file("user-config", "config", join20(home, ".codex", "config.toml"))];
   return [];
 }
 function describeAgentConfig(spec, repoPath, home = homedir10()) {
   const files = agentConfigFiles(spec, repoPath, home);
   const servers = [];
   if (spec.id === "claude") {
-    const user = readJson(join19(home, ".claude.json"));
+    const user = readJson(join20(home, ".claude.json"));
     servers.push(...serversOf(user?.mcpServers, "user"));
     if (repoPath) {
       const projects = user?.projects;
       const mine = projects?.[repoPath];
       servers.push(...serversOf(mine?.mcpServers, "local"));
-      servers.push(...serversOf(readJson(join19(repoPath, ".mcp.json"))?.mcpServers, "project"));
+      servers.push(...serversOf(readJson(join20(repoPath, ".mcp.json"))?.mcpServers, "project"));
     }
   } else if (spec.id === "codex") {
-    servers.push(...codexServers(join19(home, ".codex", "config.toml")));
+    servers.push(...codexServers(join20(home, ".codex", "config.toml")));
   }
   return { agent: spec.id, files, servers };
 }
@@ -25981,6 +26790,9 @@ var handlers = {
     s.drafts.set(msg.boxId, msg.text, msg.clientId);
     s.worktrees.spare.typed(msg.boxId, msg.text);
   },
+  "set-attachments"(msg, _ctx, s) {
+    s.drafts.setAttachments(msg.boxId, msg.items, msg.clientId);
+  },
   "refresh-git"(msg, _ctx, s) {
     s.worktrees.recount(msg.repoId);
   },
@@ -25993,19 +26805,17 @@ var handlers = {
   "forget-visit"(msg, _ctx, s) {
     s.routes.forget(msg.repoId, msg.path);
   },
-  async chat(msg, _ctx, s) {
-    await s.worktrees.send(msg.worktreeId, {
+  async chat(msg, ctx, s) {
+    await sending(s, ctx, msg, msg.attachments, () => s.worktrees.send(msg.worktreeId, {
       text: msg.text,
       clientId: msg.clientId,
       context: msg.context,
       attachments: msg.attachments
-    });
+    }));
   },
-  async "create-worktree"(msg, _ctx, s) {
-    await s.worktrees.create(msg.repoId, msg.prompt, {
+  async "create-worktree"(msg, ctx, s) {
+    const opts = {
       createdBy: msg.clientId,
-      worktreeId: msg.worktreeId,
-      variant: msg.variant,
       context: msg.context,
       attachments: msg.attachments,
       agent: msg.agent,
@@ -26014,6 +26824,30 @@ var handlers = {
       model: msg.model,
       effort: msg.effort,
       carry: msg.carry
+    };
+    const of = msg.variants ?? 1;
+    await sending(s, ctx, msg, msg.attachments, async () => {
+      if (of === 1) {
+        await s.worktrees.create(msg.repoId, msg.prompt, { ...opts, worktreeId: msg.worktreeId });
+        return;
+      }
+      const group = randomBytes5(4).toString("hex");
+      const made = await Promise.allSettled(Array.from({ length: of }, (_, i) => s.worktrees.create(msg.repoId, msg.prompt, {
+        ...opts,
+        ...i === 0 ? { worktreeId: msg.worktreeId } : {},
+        variant: { group, index: i + 1, of }
+      })));
+      const failed = made.flatMap((m) => m.status === "rejected" ? [m.reason] : []);
+      if (failed.length === 0)
+        return;
+      const went = failed.find((e) => e instanceof UserError && e.delivered);
+      if (went)
+        throw went;
+      if (failed.length < of) {
+        const why = failed[0] instanceof Error ? failed[0].message : String(failed[0]);
+        throw new UserError(`${failed.length} of ${of} attempts did not start: ${why}`, { delivered: true });
+      }
+      throw failed[0];
     });
   },
   "set-worktree-profile"(msg, _ctx, s) {
@@ -26036,6 +26870,8 @@ var handlers = {
   },
   "batch-worktrees"(msg, ctx, s) {
     const repo = s.state.requireRepo(msg.repoId);
+    if (msg.boxId)
+      s.drafts.take(msg.boxId);
     fireAndForget(msg.repoId, (async () => {
       const agent = msg.agent ?? s.state.defaultAgent ?? DEFAULT_AGENT_ID;
       const tasks = await s.planTasks(msg.prompt, repo.path, agent) ?? [msg.prompt];
@@ -26059,23 +26895,34 @@ var handlers = {
   "list-archived"(msg, ctx, s) {
     ctx.reply({ t: "archived", repoId: msg.repoId, items: s.worktrees.archived(msg.repoId) });
   },
-  async "restore-worktree"(msg, _ctx, s) {
-    await s.worktrees.restore(msg.archiveId, msg.clientId, msg.message);
+  async "restore-worktree"(msg, ctx, s) {
+    await sending(s, ctx, msg, msg.message?.attachments, async () => {
+      await s.worktrees.restore(msg.archiveId, msg.clientId, msg.message);
+    });
   },
   async "delete-archived"(msg, _ctx, s) {
     await s.worktrees.deleteArchived(msg.archiveId);
   },
-  async "adopt-worktree"(msg, _ctx, s) {
-    await s.worktrees.adopt(msg.worktreeId, msg.clientId);
+  async "adopt-worktree"(msg, ctx, s) {
+    await sending(s, ctx, msg, msg.message?.attachments, async () => {
+      await s.worktrees.adopt(msg.worktreeId, msg.clientId, msg.message);
+    });
   },
   async "git-status"(msg, ctx, s) {
     await gitStatus(s, ctx, msg.worktreeId);
   },
   async "read-file"(msg, ctx, s) {
-    const head = { t: "file-read", worktreeId: msg.worktreeId, path: msg.path, ref: msg.ref, seq: msg.seq };
+    const head = {
+      t: "file-read",
+      worktreeId: msg.worktreeId,
+      path: msg.path,
+      ref: msg.ref,
+      since: msg.since,
+      seq: msg.seq
+    };
     try {
       const kept = s.worktrees.readable(msg.worktreeId) ? null : await s.worktrees.archivedFile(msg.worktreeId, msg.path, msg.ref);
-      const read = kept ? keptRead(kept.before, kept.after) : await s.files.read(msg.worktreeId, msg.path, msg.ref);
+      const read = kept ? keptRead(kept.before, kept.after) : await s.files.read(msg.worktreeId, msg.path, msg.ref, msg.since);
       ctx.reply({ ...head, ...read });
     } catch (e) {
       if (!(e instanceof UserError))
@@ -26105,21 +26952,17 @@ var handlers = {
   },
   async land(msg, ctx, s) {
     const { result } = await s.worktrees.land(msg.worktreeId, msg.message);
-    const suggestion = !result.ok && result.conflict ? "Bring main into this branch and resolve the conflicts, then verify the app still works." : undefined;
     if (result.ok && (result.pr || s.state.worktree(msg.worktreeId)?.pr)) {
       fireAndForget(msg.worktreeId, s.prs.refresh(msg.worktreeId), "pr refresh");
     }
     await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message, {
       url: result.url,
-      ...suggestion ? { suggestion } : {}
+      ...result.asked ? { asked: true } : {}
     }));
   },
   async "sync-main"(msg, ctx, s) {
-    const { result, base } = await s.worktrees.sync(msg.worktreeId);
-    const prompt = !result.ok && result.conflict && s.state.worktree(msg.worktreeId);
-    await notify(s, ctx, msg.worktreeId, prompt ? shipped(msg.worktreeId, false, `sync conflicts with ${base}: prompt prefilled in chat`, {
-      suggestion: `Merge ${base} into this branch and resolve the conflicts, then verify the app still works.`
-    }) : shipped(msg.worktreeId, result.ok, result.message));
+    const { result } = await s.worktrees.sync(msg.worktreeId);
+    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message, result.asked ? { asked: true } : {}));
   },
   async "pull-main"(msg, ctx, s) {
     const result = await s.worktrees.pull(msg.worktreeId);
@@ -26148,7 +26991,7 @@ var handlers = {
   },
   async commit(msg, ctx, s) {
     const result = await s.worktrees.commit(msg.worktreeId, msg.message);
-    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message));
+    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message, result.asked ? { asked: true } : {}));
   },
   async graft(msg, ctx, s) {
     const { target } = await s.worktrees.graft(msg.targetId, msg.sourceIds);
@@ -26188,7 +27031,21 @@ var handlers = {
   },
   unqueue(msg, _ctx, s) {
     requireRun(s, msg.worktreeId);
-    s.runtime.agentFor(msg.worktreeId)?.unqueue(msg.index);
+    s.runtime.agentFor(msg.worktreeId)?.unqueue(msg.index, msg.edit ? (m) => s.drafts.putBack(msg.worktreeId, { text: m.text, items: m.attachments ?? [] }) : undefined);
+  },
+  async redraft(msg, _ctx, s) {
+    const r = s.worktrees.readable(msg.worktreeId);
+    const events = r?.wt ? s.runtime.ensureAgent(r.wt).agent.transcript() : s.worktrees.archivedTranscript(msg.worktreeId) ?? [];
+    const event = events.find((e) => e.seq === msg.seq)?.event;
+    if (event?.type !== "user-message")
+      throw new UserError("that message is no longer in this chat");
+    const items = [];
+    for (const ref of event.attachments ?? []) {
+      const item = await s.attachments.reattach(msg.worktreeId, ref, (file) => s.worktrees.archivedAttachment(msg.worktreeId, file));
+      if (item)
+        items.push(item);
+    }
+    s.drafts.putBack(msg.worktreeId, { text: event.text, items });
   },
   async "changed-ranges"(msg, ctx, s) {
     const { ranges, lineOffset } = await s.files.changedRanges(msg.worktreeId, msg.path);
@@ -26209,6 +27066,12 @@ var handlers = {
   async judge(msg, _ctx, s) {
     await s.landing.judge(msg.worktreeId, msg.note);
   },
+  async "fix-preview"(msg, _ctx, s) {
+    await s.worktrees.fixPreview(msg.worktreeId, msg.clientId);
+  },
+  fix(msg, _ctx, s) {
+    s.fix.press(msg.worktreeId, msg.toolId);
+  },
   async "write-file"(msg, ctx, s) {
     const head = { t: "file-written", worktreeId: msg.worktreeId, path: msg.path, seq: msg.seq };
     try {
@@ -26339,6 +27202,10 @@ var handlers = {
     s.state.setDefaultAgent(msg.agent);
     s.hub.emit("agentsChanged");
   },
+  "set-keep-awake"(msg, _ctx, s) {
+    s.state.setKeepAwake(msg.mode);
+    s.hub.emit("keepAwakeChanged");
+  },
   "rescan-themes"(_msg, _ctx, s) {
     s.themes.load();
     s.hub.emit("themesChanged");
@@ -26388,6 +27255,10 @@ var handlers = {
     if (!s.runs.stop(msg.worktreeId, msg.kind))
       throw new UserError(`no ${msg.kind} is running here`);
   },
+  "preview-start"(msg, _ctx, s) {
+    requireRun(s, msg.worktreeId);
+    s.worktrees.startPreview(msg.worktreeId);
+  },
   async "search-refs"(msg, ctx, s) {
     const refs = await s.refs.search(msg.repoId, msg.query);
     ctx.reply({ t: "refs", repoId: msg.repoId, query: msg.query, refs });
@@ -26400,6 +27271,30 @@ var handlers = {
     await s.worktrees.openRef(msg.repoId, msg.kind, msg.ref, { createdBy: msg.clientId, pr: msg.pr });
   }
 };
+async function sending(s, ctx, from, attachments, deliver) {
+  const uploads = s.attachments.uploads;
+  const { boxId, clientId } = from;
+  const named = uploadIds(attachments);
+  const boxed = boxId ? uploadIds(s.drafts.attachments(boxId)) : [];
+  const ids = [...new Set([...named, ...boxed])].filter((id) => uploads.has(id));
+  uploads.hold(ids);
+  const was = boxId ? s.drafts.take(boxId, clientId) : null;
+  try {
+    if (named.some((id) => !uploads.has(id)))
+      throw new UserError(GONE);
+    await deliver();
+  } catch (e) {
+    if (!boxId || !was || e instanceof UserError && e.delivered)
+      throw e;
+    if (!(e instanceof UserError))
+      log.error("ws", "a message reached no agent", e);
+    const items = was.items.filter((a) => !("upload" in a) || uploads.has(a.upload));
+    s.drafts.putBack(boxId, { text: was.text, items }, clientId);
+    ctx.reply({ t: "unsent", boxId, text: was.text, items, message: e instanceof Error ? e.message : String(e) });
+  } finally {
+    uploads.release(ids);
+  }
+}
 function looseCwd(s, id, stream) {
   const disc = s.worktrees.discoveredById(id);
   if (!disc)
@@ -26425,9 +27320,16 @@ async function dispatch(msg, ctx, s) {
 
 // ../daemon/src/server/http.ts
 import { existsSync as existsSync23 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 var IMMUTABLE = "private, max-age=31536000, immutable";
 var NO_STORE = "no-store";
+function attachedHeaders(imageType) {
+  return {
+    "content-type": imageType ?? "text/plain; charset=utf-8",
+    "x-content-type-options": "nosniff",
+    ...imageType ? {} : { "content-security-policy": "sandbox" }
+  };
+}
 function createFetch(opts) {
   const grant = previewGrant(opts.token);
   const remote = opts.remote;
@@ -26479,7 +27381,8 @@ function createFetch(opts) {
         dropped: new Set,
         sent: 0,
         bytes: 0,
-        view: null
+        view: null,
+        ...remoteShell ? { remote: true } : {}
       };
       const headers = authed && remote && remoteShell ? { "set-cookie": grantCookie(grant, remote.host) } : undefined;
       if (srv.upgrade(req, { data, headers }))
@@ -26515,6 +27418,13 @@ function createFetch(opts) {
       const body = { code, url: pairLink(remote.host, code), ms };
       return Response.json(body, { headers: { "cache-control": NO_STORE } });
     }
+    if (url.pathname === "/pair/phones" && req.method === "GET") {
+      if (!sameSecret(req.headers.get("authorization"), `Bearer ${opts.token}`)) {
+        return new Response("unauthorized", { status: 401 });
+      }
+      const phones = remote && isTailnetName(remote.host) ? await opts.phones() : null;
+      return Response.json(phones, { headers: { "cache-control": NO_STORE } });
+    }
     if (url.pathname === "/pair/redeem" && req.method === "POST") {
       if (!remote || !remoteShell)
         return new Response("not found", { status: 404 });
@@ -26561,6 +27471,37 @@ function createFetch(opts) {
         return new Response("open failed; see daemon log", { status: 500 });
       }
     }
+    if (url.pathname === "/uploads" && req.method === "POST") {
+      if (!sameSecret(req.headers.get("authorization"), `Bearer ${opts.token}`)) {
+        return new Response("unauthorized", { status: 401 });
+      }
+      const kind = url.searchParams.get("kind");
+      if (!isUploadKind(kind))
+        return new Response("missing kind", { status: 400 });
+      const mime = (req.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+      try {
+        const body = req.body;
+        return Response.json(await opts.attachments.uploads.put(kind, mime, body), {
+          headers: { "cache-control": NO_STORE }
+        });
+      } catch (e) {
+        if (e instanceof UserError)
+          return new Response(e.message, { status: 400 });
+        log.error("http", "upload failed", e);
+        return new Response("upload failed; see daemon log", { status: 500 });
+      }
+    }
+    if (url.pathname.startsWith("/uploads/")) {
+      if (!sameSecret(url.searchParams.get("token"), opts.token))
+        return new Response("unauthorized", { status: 401 });
+      const id = url.pathname.slice("/uploads/".length);
+      const path = opts.attachments.uploads.path(id);
+      if (!path || !existsSync23(path))
+        return new Response("not found", { status: 404 });
+      return new Response(Bun.file(path), {
+        headers: { "cache-control": IMMUTABLE, ...attachedHeaders(opts.attachments.uploads.imageType(id)) }
+      });
+    }
     if (url.pathname.startsWith("/attachments/")) {
       if (!sameSecret(url.searchParams.get("token"), opts.token))
         return new Response("unauthorized", { status: 401 });
@@ -26571,7 +27512,9 @@ function createFetch(opts) {
       const path = places.find((p) => !!p && existsSync23(p));
       if (!path)
         return new Response("not found", { status: 404 });
-      return new Response(Bun.file(path), { headers: { "cache-control": IMMUTABLE } });
+      return new Response(Bun.file(path), {
+        headers: { "cache-control": IMMUTABLE, ...attachedHeaders(drawnType(file ?? "")) }
+      });
     }
     if (url.pathname.startsWith("/files/")) {
       if (!sameSecret(url.searchParams.get("token"), opts.token))
@@ -26599,14 +27542,21 @@ function createFetch(opts) {
       });
     }
     const rel = url.pathname === "/" ? "/index.html" : url.pathname;
-    const file = join20(opts.shellDist, rel.replaceAll("..", ""));
+    const file = join21(opts.shellDist, rel.replaceAll("..", ""));
     const hashed = rel.startsWith("/assets/");
     if (existsSync23(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 };
+        return Response.json(manifest, {
+          headers: { "content-type": "application/manifest+json", "cache-control": NO_STORE }
+        });
+      }
       return new Response(Bun.file(file), { headers: { "cache-control": hashed ? IMMUTABLE : NO_STORE } });
     }
     if (hashed)
       return new Response("not found", { status: 404 });
-    const index = join20(opts.shellDist, "index.html");
+    const index = join21(opts.shellDist, "index.html");
     if (existsSync23(index))
       return new Response(Bun.file(index), { headers: { "cache-control": NO_STORE } });
     return new Response("Toyon daemon running; shell not built (run: bun run build)", { status: 200 });
@@ -26618,17 +27568,37 @@ var DROP_ABOVE_BYTES = 4 * 1024 * 1024;
 var DROPPED_NOTICE = `\r
 [toyon] output dropped: this pane was too far behind\r
 `;
+var SENDS = new Set(["chat", "create-worktree", "restore-worktree", "batch-worktrees"]);
+function sentFrom(json) {
+  if (!json || typeof json !== "object")
+    return null;
+  const { t, boxId } = json;
+  if (typeof t !== "string" || !SENDS.has(t))
+    return null;
+  return typeof boxId === "string" && boxId.length > 0 && boxId.length <= 200 ? boxId : null;
+}
+function unparsedReply(json, reason, drafts) {
+  const message = `invalid message: ${reason}`;
+  const boxId = sentFrom(json);
+  if (boxId === null)
+    return { t: "error", message };
+  return { t: "unsent", boxId, text: drafts.text(boxId), items: drafts.attachments(boxId), message };
+}
 function startServer(opts) {
   const { services: s, token, version } = opts;
   const sockets = new Set;
   const linked = new Set;
+  const counted = () => {
+    s.idleExit.clients(linked.size);
+    s.keepAwake.remoteShells([...linked].filter((ws) => ws.data.remote || ws.data.preview).length);
+  };
   const link = (ws) => {
     linked.add(ws);
-    s.idleExit.clients(linked.size);
+    counted();
   };
   const unlink = (ws) => {
     if (linked.delete(ws))
-      s.idleExit.clients(linked.size);
+      counted();
   };
   const raw = (ws, json) => {
     try {
@@ -26837,12 +27807,14 @@ function startServer(opts) {
     agentChosen: s.state.defaultAgent !== undefined
   });
   s.hub.on("agentsChanged", () => broadcast(agentsMsg()));
+  s.hub.on("keepAwakeChanged", () => broadcast({ t: "keep-awake", mode: s.keepAwake.setting() }));
   s.hub.on("selfChanged", () => broadcast({ t: "self", self: s.self.get() }));
   s.hub.on("failed", (worktreeId, message) => broadcast({ t: "error", message, worktreeId }));
   s.hub.on("updateChanged", () => broadcast({ t: "update", update: s.update.get() }));
   s.hub.on("visitsChanged", (repoId) => broadcast({ t: "visits", repoId, pages: s.routes.history(repoId) }));
   s.hub.on("archiveChanged", (repoId) => broadcast({ t: "archived", repoId, items: s.worktrees.archived(repoId) }));
   s.hub.on("draftChanged", (boxId, text, clientId) => broadcast({ t: "draft", boxId, text, ...clientId ? { clientId } : {} }));
+  s.hub.on("attachmentsChanged", (boxId, items, clientId) => broadcast({ t: "attachments", boxId, items, ...clientId ? { clientId } : {} }));
   const helloFrame = async () => {
     await s.update.refresh();
     return {
@@ -26861,6 +27833,7 @@ function startServer(opts) {
       agentChosen: s.state.defaultAgent !== undefined,
       home: homedir11(),
       folderDialog: process.platform === "darwin" && !cloud.enabled,
+      keepAwake: s.keepAwake.setting(),
       remote: opts.remote && { host: opts.remote.host, previews: opts.remote.previews },
       paired: s.state.paired,
       gitIdentity: await s.repos.gitIdentity(),
@@ -26869,11 +27842,13 @@ function startServer(opts) {
       self: s.self.get(),
       update: s.update.get(),
       drafts: s.drafts.all(),
+      attachments: s.drafts.allAttachments(),
       managed: managedView(opts.managed)
     };
   };
   let branded = false;
   const serverConfig = {
+    maxRequestBodySize: UPLOAD_MAX_BYTES,
     hostname: cloud.bindHost,
     fetch: createFetch({
       token,
@@ -26891,6 +27866,10 @@ function startServer(opts) {
       managed: { source: opts.managed.source, hash: opts.managed.hash },
       preview: (id) => s.runtime.get(id)?.proxy?.handler ?? null,
       bootstrap: helloFrame,
+      manifestColors: () => {
+        const { surface0, surface1 } = s.themes.current().colors;
+        return { bar: surface1, ground: surface0 };
+      },
       open: (path) => s.opens.open(path),
       restart: (now) => s.restarter.request({ now }),
       restartWait: () => ({ waiting: s.restarter.waitingOn(), asking: s.restarter.asking() }),
@@ -26898,10 +27877,10 @@ function startServer(opts) {
       onPaired: () => {
         s.state.notePaired();
         broadcast({ t: "paired" });
-      }
+      },
+      phones: () => readTailnetPhones()
     }),
     websocket: {
-      maxPayloadLength: 64 * 1024 * 1024,
       async open(ws) {
         const preview = ws.data.preview;
         if (preview) {
@@ -26943,7 +27922,7 @@ function startServer(opts) {
         }
         const parsed = parseClientMsg(json);
         if (!parsed.ok) {
-          send(ws, { t: "error", message: `invalid message: ${parsed.reason}` });
+          send(ws, unparsedReply(json, parsed.reason, s.drafts));
           return;
         }
         const ctx = {
@@ -27010,16 +27989,16 @@ function startServer(opts) {
 }
 
 // ../daemon/src/themes/store.ts
-import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync9, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync24, readdirSync as readdirSync7, readFileSync as readFileSync15, statSync as statSync9, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir12 } from "os";
-import { basename as basename6, dirname as dirname8, join as join21, resolve as resolve9 } from "path";
+import { basename as basename6, dirname as dirname8, join as join22, resolve as resolve9 } from "path";
 var home = homedir12();
 var defaultExtensionDirs = [
-  join21(home, ".vscode", "extensions"),
-  join21(home, ".vscode-insiders", "extensions"),
-  join21(home, ".vscode-oss", "extensions"),
-  join21(home, ".cursor", "extensions"),
-  join21(home, ".windsurf", "extensions"),
+  join22(home, ".vscode", "extensions"),
+  join22(home, ".vscode-insiders", "extensions"),
+  join22(home, ".vscode-oss", "extensions"),
+  join22(home, ".cursor", "extensions"),
+  join22(home, ".windsurf", "extensions"),
   "/Applications/Visual Studio Code.app/Contents/Resources/app/extensions",
   "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions",
   "/Applications/Cursor.app/Contents/Resources/app/extensions",
@@ -27103,7 +28082,7 @@ class ThemeStore {
       name: json?.name ?? base,
       source: "file"
     });
-    writeFileSync8(join21(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
+    writeFileSync8(join22(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
 `);
     this.load();
     return theme;
@@ -27135,10 +28114,10 @@ function loadDir(dir) {
   if (!existsSync24(dir))
     return [];
   const out = [];
-  for (const f of readdirSync6(dir)) {
+  for (const f of readdirSync7(dir)) {
     if (!/\.jsonc?$/i.test(f))
       continue;
-    const file = join21(dir, f);
+    const file = join22(dir, f);
     const id = `file:${slug(f.replace(/\.(json|jsonc)$/i, ""))}`;
     try {
       const json = readJsonc(file);
@@ -27159,13 +28138,13 @@ function discover(dir) {
   const out = [];
   let entries;
   try {
-    entries = readdirSync6(dir);
+    entries = readdirSync7(dir);
   } catch {
     return out;
   }
   for (const name of entries) {
-    const extDir = join21(dir, name);
-    const pkgFile = join21(extDir, "package.json");
+    const extDir = join22(dir, name);
+    const pkgFile = join22(extDir, "package.json");
     try {
       if (!statSync9(extDir).isDirectory() || !existsSync24(pkgFile))
         continue;
@@ -27175,7 +28154,7 @@ function discover(dir) {
         continue;
       const ext = `${pkg.publisher ?? "local"}.${pkg.name ?? name}`;
       let nls = {};
-      const nlsFile = join21(extDir, "package.nls.json");
+      const nlsFile = join22(extDir, "package.nls.json");
       if (existsSync24(nlsFile)) {
         try {
           nls = JSON.parse(readFileSync15(nlsFile, "utf8"));
@@ -27591,8 +28570,8 @@ class BackendShare {
 // ../daemon/src/worktrees/cache.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync25, readFileSync as readFileSync16 } from "fs";
-import { mkdir as mkdir4, readdir as readdir2, rename, rm as rm3, stat as stat3, utimes, writeFile as writeFile2 } from "fs/promises";
-import { join as join22 } from "path";
+import { mkdir as mkdir4, readdir as readdir2, rename, rm as rm3, stat as stat4, utimes, writeFile as writeFile2 } from "fs/promises";
+import { join as join23 } from "path";
 
 // ../daemon/src/core/clone.ts
 import { mkdir as mkdir3, rm as rm2 } from "fs/promises";
@@ -27623,7 +28602,7 @@ var STALE_MS = 30 * 24 * 3600000;
 var TMP = ".tmp-";
 var MANIFEST = "manifest.json";
 function defaultTools(dir) {
-  const has = (...files) => files.some((f) => existsSync25(join22(dir, f)));
+  const has = (...files) => files.some((f) => existsSync25(join23(dir, f)));
   const out = [];
   if (has("bun.lock", "bun.lockb"))
     out.push("bun --version");
@@ -27636,7 +28615,7 @@ function defaultTools(dir) {
   return out;
 }
 function withSidecars(root, rel) {
-  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync25(join22(root, n)));
+  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync25(join23(root, n)));
 }
 var entryName = (base, at) => `${base.slice(0, 12)}-${at.toString(36)}`;
 async function listEntries(familyDir) {
@@ -27651,8 +28630,8 @@ async function listEntries(familyDir) {
     const m = /^([0-9a-f]{12})-([0-9a-z]+)$/.exec(name);
     if (!m?.[1] || !m[2])
       continue;
-    const dir = join22(familyDir, name);
-    if (!existsSync25(join22(dir, MANIFEST)))
+    const dir = join23(familyDir, name);
+    if (!existsSync25(join23(dir, MANIFEST)))
       continue;
     out.push({ dir, base: m[1], at: Number.parseInt(m[2], 36) });
   }
@@ -27682,7 +28661,7 @@ class ArtifactCache {
     try {
       const family = await this.family(wt, repo, policy);
       const base = await this.baseCommit(wt, repo);
-      const entries = await listEntries(join22(this.d.paths.cacheDir, repo.id, family.key));
+      const entries = await listEntries(join23(this.d.paths.cacheDir, repo.id, family.key));
       const entry = entries.find((e) => e.base === base.slice(0, 12)) ?? entries[0];
       if (!entry) {
         say(`cache: nothing kept for these lockfiles and tools on ${family.platform}`);
@@ -27690,14 +28669,14 @@ class ArtifactCache {
       }
       const restored = [];
       for (const rel of policy.paths) {
-        if (existsSync25(join22(wt.path, rel)))
+        if (existsSync25(join23(wt.path, rel)))
           continue;
         const names = withSidecars(entry.dir, rel);
         if (names.length === 0)
           continue;
         let whole = true;
         for (const name of names) {
-          const r = await (this.d.clone ?? cloneTree)(join22(entry.dir, name), join22(wt.path, name));
+          const r = await (this.d.clone ?? cloneTree)(join23(entry.dir, name), join23(wt.path, name));
           if (r.ok)
             continue;
           say(`cache: could not restore ${name}: ${r.error}`);
@@ -27731,12 +28710,12 @@ class ArtifactCache {
     let tmp;
     let slot;
     try {
-      const present = policy.paths.filter((rel) => existsSync25(join22(wt.path, rel)));
+      const present = policy.paths.filter((rel) => existsSync25(join23(wt.path, rel)));
       if (present.length === 0)
         return;
       const family = await this.family(wt, repo, policy);
       const base = await this.baseCommit(wt, repo);
-      const familyDir = join22(this.d.paths.cacheDir, repo.id, family.key);
+      const familyDir = join23(this.d.paths.cacheDir, repo.id, family.key);
       const key = `${familyDir}/${base.slice(0, 12)}`;
       const kept = (await listEntries(familyDir)).find((e) => e.base === base.slice(0, 12));
       if (kept || this.making.has(key)) {
@@ -27747,21 +28726,21 @@ class ArtifactCache {
       this.making.add(key);
       const at = Date.now();
       const name = entryName(base, at);
-      tmp = join22(familyDir, `${TMP}${name}`);
+      tmp = join23(familyDir, `${TMP}${name}`);
       await mkdir4(tmp, { recursive: true });
       let how = "clonefile";
       for (const rel of present) {
         for (const n of withSidecars(wt.path, rel)) {
-          const r = await (this.d.clone ?? cloneTree)(join22(wt.path, n), join22(tmp, n));
+          const r = await (this.d.clone ?? cloneTree)(join23(wt.path, n), join23(tmp, n));
           if (!r.ok)
             throw new Error(`could not keep ${n}: ${r.error}`);
           how = r.how;
         }
       }
       const manifest = { at, base, platform: family.platform, tools: family.tools, paths: present };
-      await writeFile2(join22(tmp, MANIFEST), `${JSON.stringify(manifest, null, 2)}
+      await writeFile2(join23(tmp, MANIFEST), `${JSON.stringify(manifest, null, 2)}
 `);
-      await rename(tmp, join22(familyDir, name));
+      await rename(tmp, join23(familyDir, name));
       tmp = undefined;
       log.info(worktreeId, `cache: kept ${list(present)} for ${base.slice(0, 7)} via ${how} in ${Date.now() - started}ms`);
       await this.prune(familyDir);
@@ -27789,7 +28768,7 @@ class ArtifactCache {
       return;
     }
     for (const repoId of repoIds) {
-      const repoDir = join22(root, repoId);
+      const repoDir = join23(root, repoId);
       if (!this.d.state.repo(repoId)) {
         await rm3(repoDir, { recursive: true, force: true });
         continue;
@@ -27801,7 +28780,7 @@ class ArtifactCache {
         continue;
       }
       for (const family of families) {
-        const familyDir = join22(repoDir, family);
+        const familyDir = join23(repoDir, family);
         let names;
         try {
           names = await readdir2(familyDir);
@@ -27810,11 +28789,11 @@ class ArtifactCache {
         }
         for (const n of names)
           if (n.startsWith(TMP))
-            await rm3(join22(familyDir, n), { recursive: true, force: true });
+            await rm3(join23(familyDir, n), { recursive: true, force: true });
         const entries = await listEntries(familyDir);
         let newest = 0;
         for (const e of entries) {
-          const s = await stat3(e.dir).catch(() => null);
+          const s = await stat4(e.dir).catch(() => null);
           if (s)
             newest = Math.max(newest, s.mtimeMs);
         }
@@ -27830,7 +28809,7 @@ class ArtifactCache {
     for (const f of policy.key) {
       h.update(`\x00${f}\x00`);
       try {
-        h.update(readFileSync16(join22(wt.path, f)));
+        h.update(readFileSync16(join23(wt.path, f)));
       } catch {
         h.update("(absent)");
       }
@@ -27995,6 +28974,92 @@ class ChatSearch {
   }
 }
 
+// ../daemon/src/worktrees/fix.ts
+var RESPONSE = {
+  hook: { does: "ask" },
+  conflict: { does: "ask" },
+  check: { does: "ask", once: true },
+  command: { does: "offer" },
+  preview: { does: "offer" }
+};
+function lastAsked(entries) {
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const e = entries[i].event;
+    if (e.type === "fix-asked")
+      return e.kind;
+    if (e.type === "user-message")
+      return;
+  }
+  return;
+}
+function askedFor(entries, toolId) {
+  return entries.some(({ event }) => event.type === "fix-asked" && event.toolId === toolId);
+}
+function failureOf(entries, toolId) {
+  let command;
+  for (const { event } of entries) {
+    if (event.type === "tool-start" && event.toolId === toolId) {
+      const input = event.input;
+      command = typeof input?.command === "string" ? input.command : undefined;
+    } else if (event.type === "tool-end" && event.toolId === toolId) {
+      if (!event.fixable || command === undefined)
+        return null;
+      const run = { toolId, command, text: unformatOutput(event.output ?? "") };
+      if (event.fixable.kind === "hook")
+        return { kind: "hook", hook: event.fixable.hook ?? "git", ...run };
+      return { kind: event.fixable.kind, ...run };
+    }
+  }
+  return null;
+}
+
+class FixService {
+  d;
+  constructor(d) {
+    this.d = d;
+    d.hub.on("checkFailed", (id, run) => {
+      this.report(id, { kind: "check", ...run });
+    });
+  }
+  report(worktreeId, failure, opts = {}) {
+    const response = RESPONSE[failure.kind];
+    if (response.does === "offer" && !opts.pressed)
+      return false;
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt || isMain(wt))
+      return false;
+    const agent = this.d.runtime.agentFor(worktreeId);
+    if (!agent)
+      return false;
+    const entries = agent.transcript();
+    if (response.once && !opts.pressed && lastAsked(entries) === failure.kind)
+      return false;
+    const toolId = failedRun(failure)?.toolId;
+    if (toolId && askedFor(entries, toolId))
+      return false;
+    const context = failureContext(failure);
+    agent.send(fixPrompt(failure), {
+      asked: { kind: failure.kind, why: fixWhy(failure), ...toolId ? { toolId } : {} },
+      ...context ? { context: [context] } : {}
+    });
+    return true;
+  }
+  press(worktreeId, toolId) {
+    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 entries = agent.transcript();
+    const failure = failureOf(entries, toolId);
+    if (!failure)
+      throw new UserError("nothing to fix on that row");
+    if (askedFor(entries, toolId))
+      return;
+    if (!this.report(worktreeId, failure, { pressed: true }))
+      throw new UserError("nothing runs on main");
+  }
+}
+
 // ../daemon/src/worktrees/landing.ts
 var TAIL_CHARS = 400;
 var DIFF_CHARS = 2000;
@@ -28008,6 +29073,7 @@ class LandingService {
   constructor(d) {
     this.d = d;
     d.hub.on("turnSettled", (id, turn) => fireAndForget(id, this.settle(id, turn), "landing verdict"));
+    d.hub.on("messageRefused", (id, said) => fireAndForget(id, this.judge(id, `The commit-msg hook refused the last message, saying: ${said}`), "landing message after a refusal"));
     d.hub.on("agentStatus", (id, status) => {
       this.note(id, status);
       if (status === "working")
@@ -28178,6 +29244,7 @@ class LandingService {
     let check = "none";
     let checkTail;
     let waited = 0;
+    let ran;
     const command = repo.config.check?.trim();
     if (command) {
       const ceiling = timeoutFor(repo.config, "check");
@@ -28201,6 +29268,7 @@ class LandingService {
       run.finish(r.exit);
       if (!live())
         return;
+      ran = r;
       check = r.exit === 0 ? "pass" : "fail";
       if (r.exit === "timeout") {
         checkTail = [`gave up after ${describeDuration(ceiling)}`, tail(r.text)].filter(Boolean).join(`
@@ -28256,6 +29324,8 @@ class LandingService {
       record.recap = { at: Date.now(), text: verdict.recap };
     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 });
   }
   async sharedMigration(wt, repo) {
     if (!repo.services || keepsCopiesApart(repo.config))
@@ -28660,12 +29730,12 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { cpSync, existsSync as existsSync28, readFileSync as readFileSync18, rmSync as rmSync5 } from "fs";
+import { cpSync, existsSync as existsSync30, readFileSync as readFileSync18, rmSync as rmSync7 } from "fs";
 import { rm as rm4 } from "fs/promises";
-import { dirname as dirname11, join as join25 } from "path";
+import { dirname as dirname11, join as join27 } from "path";
 
 // ../daemon/src/git/archive.ts
-import { rmSync as rmSync3 } from "fs";
+import { rmSync as rmSync4 } from "fs";
 var archiveRef = (worktreeId) => `refs/toyon/archive/${worktreeId}`;
 var SNAPSHOT_SUBJECT = "toyon: uncommitted work";
 var SNAPSHOT_AUTHOR = "toyon";
@@ -28708,7 +29778,7 @@ async function snapshotCommit(wtPath, head, indexFile) {
     ], wtPath);
     return commit.ok ? commit.out : null;
   } finally {
-    rmSync3(indexFile, { force: true });
+    rmSync4(indexFile, { force: true });
   }
 }
 async function keptAt(repoPath, ref) {
@@ -28786,7 +29856,11 @@ async function dropLandRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/git/land.ts
+import { existsSync as existsSync26 } 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;
+}
 var stepRun = (cwd, args, onText, signal, opts = {}) => runWatched(GIT, args, cwd, { env: NO_PROMPT, onText, signal, ...opts, timeoutMs: opts.timeoutMs ?? STEP_TIMEOUT_MS });
 var UNWATCHED = {
   step() {},
@@ -28799,6 +29873,14 @@ function refused(what, r, n = 200) {
   }
   return `${what}: ${r.shown ? "what git and its hooks printed is on the chat" : r.err.slice(0, n)}`;
 }
+function stepRefused(what, r, n = 200) {
+  const row = typeof r.exit === "number" && r.hook ? rowOf(r) : undefined;
+  return {
+    ok: false,
+    message: refused(what, r, n),
+    ...row && r.hook ? { hook: { ...row, name: r.hook } } : {}
+  };
+}
 async function commitWorktree(worktreePath, message, w = UNWATCHED) {
   if ((await statusFiles(worktreePath)).length === 0)
     return { ok: false, message: "nothing to commit" };
@@ -28806,7 +29888,7 @@ async function commitWorktree(worktreePath, message, w = UNWATCHED) {
   w.step("committing");
   const c = await w.git(worktreePath, ["commit", "-m", message]);
   if (!c.ok)
-    return { ok: false, message: refused("commit refused", c) };
+    return stepRefused("commit refused", c);
   return { ok: true, message: `committed: ${message}` };
 }
 async function requireClean(worktreePath) {
@@ -28892,7 +29974,27 @@ async function putBack(worktreePath, defaultBr, aside, taken) {
     message: `the uncommitted changes here conflict with ${defaultBr}${named}: commit them first, then sync`
   };
 }
+var MIDWAY = [
+  ["MERGE_HEAD", "merge"],
+  ["rebase-merge", "rebase"],
+  ["rebase-apply", "rebase"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"]
+];
+async function midway(worktreePath) {
+  const args = MIDWAY.flatMap(([file]) => ["--git-path", file]);
+  const r = await git(worktreePath, "rev-parse", "--path-format=absolute", ...args);
+  if (!r.ok)
+    return null;
+  const at = r.out.split(`
+`).findIndex((file) => file && existsSync26(file));
+  return MIDWAY[at]?.[1] ?? null;
+}
 async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = false) {
+  const unfinished = await midway(worktreePath);
+  if (unfinished) {
+    return { ok: false, message: `a ${unfinished} is unfinished here: finish or abort it first` };
+  }
   if (!carry) {
     const cErr = await requireClean(worktreePath);
     if (cErr)
@@ -28907,8 +30009,19 @@ async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = f
   const taken = await bringIn(worktreePath, defaultBr, own, behind, w);
   return aside ? putBack(worktreePath, defaultBr, aside, taken) : taken;
 }
+async function requireLinear(worktreePath, base) {
+  const merges = await git(worktreePath, "rev-list", "--merges", "--count", `${base}..HEAD`);
+  if (!merges.ok || merges.out === "0")
+    return null;
+  return {
+    ok: false,
+    conflict: "rebase",
+    message: `the branch holds a merge commit, which landing by rebase would put on ${base}: ask the agent to rebase onto ${base} first`
+  };
+}
 async function bringIn(worktreePath, defaultBr, own, behind, w) {
-  if (own) {
+  const merges = own ? await git(worktreePath, "rev-list", "--merges", "--count", `${defaultBr}..HEAD`) : null;
+  if (own && merges?.out === "0") {
     w.step(`rebasing onto ${defaultBr}`);
     const r = await w.git(worktreePath, ["rebase", defaultBr]);
     if (!r.ok) {
@@ -28916,10 +30029,12 @@ async function bringIn(worktreePath, defaultBr, own, behind, w) {
       const files = overwritten(r.text);
       if (files.length)
         return { ok: false, message: untrackedInTheWay(defaultBr, files) };
-      const ask = `rebase onto ${defaultBr} conflicts: ask the agent to bring ${defaultBr} in and resolve them`;
+      const ask = `rebase onto ${defaultBr} conflicts: ask the agent to rebase onto ${defaultBr} and resolve them`;
+      const step = rowOf(r);
       return {
         ok: false,
-        conflict: true,
+        conflict: "rebase",
+        ...step ? { step } : {},
         message: r.shown ? `${ask}; the conflicts are on the chat` : `${ask} (${r.text.slice(0, 200)})`
       };
     }
@@ -28966,7 +30081,7 @@ async function landLocally(worktreePath, branch, repoPath, defaultBr, method, me
     const c = await w.git(repoPath, ["commit", "-m", message]);
     if (!c.ok) {
       await git(repoPath, "reset", "--hard", "HEAD");
-      return { ok: false, message: refused("squash commit refused", c) };
+      return stepRefused("squash commit refused", c);
     }
     return { ok: true, message: `squashed ${branch} onto ${defaultBr}` };
   }
@@ -29025,7 +30140,7 @@ async function landingCommit(worktreePath, branch, base, method, message, own, w
     const c = await w.git(worktreePath, ["commit", "-m", message]);
     if (!c.ok) {
       await git(worktreePath, "reset", "--soft", head.out);
-      return { ok: false, message: refused("squash commit refused", c) };
+      return stepRefused("squash commit refused", c);
     }
     const sha = await git(worktreePath, "rev-parse", "HEAD");
     return { ok: true, sha: sha.out, message: `squashed ${branch} onto ${base}` };
@@ -29038,15 +30153,15 @@ async function landingCommit(worktreePath, branch, base, method, message, own, w
       w.step(`squashing onto ${base}`);
       const s = await w.git(worktreePath, ["merge", "--squash", branch]);
       if (!s.ok)
-        return { ok: false, message: refused("squash refused", s) };
+        return stepRefused("squash refused", s);
       const c = await w.git(worktreePath, ["commit", "-m", message]);
       if (!c.ok)
-        return { ok: false, message: refused("squash commit refused", c) };
+        return stepRefused("squash commit refused", c);
     } else {
       w.step(`merging into ${base}`);
       const m = await w.git(worktreePath, ["merge", "--no-ff", "-m", `Merge branch '${branch}'`, branch]);
       if (!m.ok)
-        return { ok: false, message: refused("merge refused", m) };
+        return stepRefused("merge refused", m);
     }
     const sha = await git(worktreePath, "rev-parse", "HEAD");
     return { ok: true, sha: sha.out, message: `${method === "squash" ? "squashed" : "merged"} ${branch} onto ${base}` };
@@ -29073,15 +30188,17 @@ async function pushLanding(worktreePath, sha, defaultBr, w = UNWATCHED) {
   if (p.ok)
     return { ok: true, message: `pushed ${defaultBr} to ${tracked.remote}` };
   const moved = /\[rejected\]|fetch first|non-fast-forward|cannot lock ref/.test(p.err);
-  return moved ? { ok: false, moved: true, message: `${defaultBr} on ${tracked.remote} moved while landing` } : { ok: false, message: refused("push failed", p, 300) };
+  return moved ? { ok: false, moved: true, message: `${defaultBr} on ${tracked.remote} moved while landing` } : stepRefused("push failed", p, 300);
 }
 async function mergeFailure(cwd, m, conflictMessage) {
   const conflict = /CONFLICT|Automatic merge failed/.test(m.text);
   if (conflict) {
     await git(cwd, "merge", "--abort");
+    const step = rowOf(m);
     return {
       ok: false,
-      conflict: true,
+      conflict: "merge",
+      ...step ? { step } : {},
       message: m.shown ? `${conflictMessage}; the conflicts are on the chat` : `${conflictMessage} (${m.text.slice(0, 200)})`
     };
   }
@@ -29112,7 +30229,7 @@ async function pushBranch(worktreePath, branch, w = UNWATCHED) {
     push = await w.git(worktreePath, args);
   }
   if (!push.ok)
-    return { ok: false, message: refused("push failed", push, 300) };
+    return stepRefused("push failed", push, 300);
   return { ok: true, message: `pushed ${branch}` };
 }
 async function goneFromOrigin(worktreePath, branch) {
@@ -29183,18 +30300,142 @@ function compareUrl(remoteUrl, base, branch) {
   return `https://github.com/${m[1]}/compare/${encodeURIComponent(base)}...${encodeURIComponent(branch)}?expand=1`;
 }
 
+// ../daemon/src/git/turn.ts
+import { copyFileSync, existsSync as existsSync27, rmSync as rmSync5 } from "fs";
+import { join as join24 } from "path";
+var turnRef = (worktreeId, which) => `refs/toyon/turns/${worktreeId}/${which}`;
+var SNAPSHOT_SUBJECT2 = "toyon: tree at a send";
+var queue = new Map;
+function inTurn(wtPath, job) {
+  const next = (queue.get(wtPath) ?? Promise.resolve()).then(job, job);
+  queue.set(wtPath, next.catch(() => {}));
+  return next;
+}
+var synced = new Map;
+var MAX_PATHS = 400;
+async function treeNow(wtPath, head, dirty) {
+  let was = synced.get(wtPath);
+  let index = was?.index;
+  if (!index) {
+    const dir = await git(wtPath, "rev-parse", "--absolute-git-dir");
+    if (!dir.ok || !dir.out)
+      return null;
+    index = join24(dir.out, "toyon-turn-index");
+  }
+  const env = { GIT_INDEX_FILE: index };
+  const writeTree = async () => {
+    const tree = await run(GIT, ["write-tree"], wtPath, env);
+    return tree.ok && tree.out ? tree.out : null;
+  };
+  if (!existsSync27(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) {
+    const again = [...new Set([...was.dirty, ...paths])];
+    if (again.length <= MAX_PATHS) {
+      const added = again.length === 0 || (await run(GIT, ["--literal-pathspecs", "add", "-A", "--", ...again], wtPath, env)).ok;
+      const tree = added ? await writeTree() : null;
+      if (tree) {
+        synced.set(wtPath, { index, head, dirty: new Set(paths) });
+        return tree;
+      }
+    }
+  }
+  synced.delete(wtPath);
+  if (!existsSync27(index)) {
+    const own = join24(index, "..", "index");
+    if (existsSync27(own))
+      copyFileSync(own, index);
+    else if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
+      return null;
+  }
+  const full = async () => (await run(GIT, ["add", "-A"], wtPath, env)).ok ? writeTree() : null;
+  let tree = await full();
+  if (!tree) {
+    rmSync5(index, { force: true });
+    if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
+      return null;
+    tree = await full();
+    if (!tree)
+      return null;
+  }
+  const differs = await git(wtPath, "diff", "--name-only", "--no-renames", "-z", head, tree);
+  if (differs.ok)
+    synced.set(wtPath, { index, head, dirty: new Set(differs.out.split("\x00").filter(Boolean)) });
+  return tree;
+}
+async function snapshotAt(wtPath, ref) {
+  const r = await git(wtPath, "rev-parse", "--quiet", `${ref}^{commit}`, `${ref}^{tree}`, `${ref}^`);
+  const [commit, tree, parent] = r.ok ? r.out.split(`
+`) : [];
+  return commit && tree && parent ? { commit, tree, parent } : null;
+}
+function markTurn(wtPath, worktreeId) {
+  return inTurn(wtPath, async () => {
+    const head = await git(wtPath, "rev-parse", "--verify", "HEAD");
+    if (!head.ok)
+      return;
+    const tree = await treeNow(wtPath, head.out);
+    if (!tree)
+      return;
+    const at = await snapshotAt(wtPath, turnRef(worktreeId, "at"));
+    if (at?.tree === tree && at.parent === head.out)
+      return;
+    const commit = await git(wtPath, "-c", "user.name=toyon", "-c", "user.email=toyon@localhost", "commit-tree", tree, "-p", head.out, "-m", SNAPSHOT_SUBJECT2);
+    if (!commit.ok)
+      return;
+    if (at && at.tree !== tree)
+      await git(wtPath, "update-ref", turnRef(worktreeId, "before"), at.commit);
+    await git(wtPath, "update-ref", turnRef(worktreeId, "at"), commit.out);
+  });
+}
+function turnChanges(wtPath, worktreeId, defaultBr, own, dirty) {
+  return inTurn(wtPath, async () => {
+    const at = await snapshotAt(wtPath, turnRef(worktreeId, "at"));
+    if (!at)
+      return null;
+    const head = await git(wtPath, "rev-parse", "HEAD", "HEAD^{tree}");
+    const [headCommit, headTree] = head.ok ? head.out.split(`
+`) : [];
+    if (!headCommit)
+      return null;
+    const tree = await treeNow(wtPath, headCommit, dirty);
+    if (!tree)
+      return null;
+    const from = at.tree !== tree ? at : await snapshotAt(wtPath, turnRef(worktreeId, "before"));
+    if (!from || from.tree === tree || from.tree === headTree)
+      return null;
+    if (from.parent !== headCommit) {
+      if (!own)
+        return null;
+      const [then, now] = await Promise.all([
+        git(wtPath, "merge-base", from.parent, defaultBr),
+        git(wtPath, "merge-base", headCommit, defaultBr)
+      ]);
+      if (!then.ok || !now.ok || then.out !== now.out)
+        return null;
+    }
+    const files = await filesBetween(wtPath, from.commit, tree);
+    return files.length > 0 ? { base: from.commit, files } : null;
+  });
+}
+async function dropTurnRefs(repoPath, worktreeId) {
+  for (const which of ["at", "before"])
+    await git(repoPath, "update-ref", "-d", turnRef(worktreeId, which));
+}
+
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync7, readdirSync as readdirSync7, readFileSync as readFileSync17, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
-import { basename as basename8, dirname as dirname10, join as join23 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync8, readdirSync as readdirSync8, readFileSync as readFileSync17, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename8, dirname as dirname10, join as join25 } from "path";
 class WorktreeArchive {
   dir;
   records = new Map;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync7(dir, { recursive: true });
-    for (const id of readdirSync7(dir)) {
+    mkdirSync8(dir, { recursive: true });
+    for (const id of readdirSync8(dir)) {
       const file = this.filesOf(id).record;
-      if (!existsSync26(file))
+      if (!existsSync28(file))
         continue;
       try {
         this.records.set(id, JSON.parse(readFileSync17(file, "utf8")));
@@ -29208,7 +30449,7 @@ class WorktreeArchive {
   }
   put(rec, from) {
     const at = this.filesOf(rec.worktree.id);
-    mkdirSync7(at.dir, { recursive: true });
+    mkdirSync8(at.dir, { recursive: true });
     move(from.transcript, at.transcript);
     move(from.attachments, at.attachments);
     move(from.plans, at.plans);
@@ -29228,7 +30469,7 @@ class WorktreeArchive {
   delete(id) {
     if (!this.records.has(id))
       return;
-    rmSync4(this.filesOf(id).dir, { recursive: true, force: true });
+    rmSync6(this.filesOf(id).dir, { recursive: true, force: true });
     this.records.delete(id);
   }
   list(repo) {
@@ -29243,8 +30484,8 @@ class WorktreeArchive {
   planFile(id, rel) {
     if (!this.records.has(id) || !isPlanPath(rel))
       return null;
-    const file = join23(this.filesOf(id).plans, basename8(rel));
-    if (!existsSync26(file))
+    const file = join25(this.filesOf(id).plans, basename8(rel));
+    if (!existsSync28(file))
       return null;
     try {
       return readFileSync17(file, "utf8");
@@ -29254,13 +30495,13 @@ class WorktreeArchive {
     }
   }
   filesOf(id) {
-    const dir = join23(this.dir, id);
+    const dir = join25(this.dir, id);
     return {
       dir,
-      record: join23(dir, "record.json"),
-      transcript: join23(dir, "transcript.jsonl"),
-      attachments: join23(dir, "attachments"),
-      plans: join23(dir, "plans")
+      record: join25(dir, "record.json"),
+      transcript: join25(dir, "transcript.jsonl"),
+      attachments: join25(dir, "attachments"),
+      plans: join25(dir, "plans")
     };
   }
 }
@@ -29285,7 +30526,7 @@ function summarize(r, repoId, transcript) {
   };
 }
 function lastUsage(transcript) {
-  if (!existsSync26(transcript))
+  if (!existsSync28(transcript))
     return null;
   const lines = readFileSync17(transcript, "utf8").split(`
 `);
@@ -29301,7 +30542,7 @@ function lastUsage(transcript) {
   return null;
 }
 function firstPrompt(transcript) {
-  if (!existsSync26(transcript))
+  if (!existsSync28(transcript))
     return;
   for (const line of readFileSync17(transcript, "utf8").split(`
 `)) {
@@ -29316,10 +30557,10 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync26(from))
+  if (!existsSync28(from))
     return;
-  mkdirSync7(dirname10(to), { recursive: true });
-  rmSync4(to, { recursive: true, force: true });
+  mkdirSync8(dirname10(to), { recursive: true });
+  rmSync6(to, { recursive: true, force: true });
   renameSync4(from, to);
 }
 
@@ -29381,8 +30622,8 @@ class ArchivedGit {
 }
 
 // ../daemon/src/worktrees/spare.ts
-import { existsSync as existsSync27 } from "fs";
-import { basename as basename9, join as join24 } from "path";
+import { existsSync as existsSync29 } from "fs";
+import { basename as basename9, join as join26 } from "path";
 class SparePool {
   d;
   inflight = new Map;
@@ -29401,7 +30642,7 @@ class SparePool {
     if (!text.trim())
       return;
     const wt = this.d.state.worktree(boxId);
-    if (wt?.kind !== "spare" || !existsSync27(wt.path))
+    if (wt?.kind !== "spare" || !existsSync29(wt.path))
       return;
     const agent = this.d.runtime.ensureAgent(wt).agent;
     if (agent.runningAgent === null)
@@ -29446,11 +30687,11 @@ class SparePool {
     return this.record(repoId, repo).then((wt) => this.warmUp(wt, repo, {}));
   }
   async record(repoId, repo) {
-    const { id, dir } = freeSlot(join24(this.d.paths.worktreesDir, repo.name));
+    const { id, dir } = freeSlot(join26(this.d.paths.worktreesDir, repo.name));
     const wt = {
       id,
       repoId,
-      path: join24(this.d.paths.worktreesDir, repo.name, dir),
+      path: join26(this.d.paths.worktreesDir, repo.name, dir),
       branch: repo.defaultBranch,
       kind: "spare",
       phase: "reserved",
@@ -29465,7 +30706,7 @@ class SparePool {
     const repoId = repo.id;
     let cut = () => {};
     const added = (async () => {
-      if (existsSync27(wt.path))
+      if (existsSync29(wt.path))
         return;
       await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--detach", wt.path, baseOf(repo)));
     })();
@@ -29513,7 +30754,7 @@ class SparePool {
     }
     log.warn(wt.repoId, "spare warm-up failed; rolling back", e);
     this.d.carryDraft?.(wt.id, wt.repoId);
-    if (existsSync27(wt.path)) {
+    if (existsSync29(wt.path)) {
       await this.d.discard(wt.id).catch((re) => log.warn(wt.repoId, "spare rollback failed", re));
       return;
     }
@@ -29570,7 +30811,7 @@ class SparePool {
       const running = this.inflight.get(repoId);
       await running?.added.catch(() => {});
       running?.cut();
-      if (wt.kind !== "spare" || !existsSync27(wt.path))
+      if (wt.kind !== "spare" || !existsSync29(wt.path))
         return null;
     }
     await this.refreshing.get(repoId);
@@ -29616,7 +30857,7 @@ class Trunk {
     const last = this.lastFetch.get(path) ?? 0;
     if (Date.now() - last > FETCH_EVERY_MS) {
       this.lastFetch.set(path, Date.now());
-      fireAndForget("fetch", run(GIT, ["fetch", "--quiet"], path, NO_PROMPT).then(async (r) => {
+      fireAndForget("fetch", withFetchLock(path, () => run(GIT, ["fetch", "--quiet"], path, NO_PROMPT)).then(async (r) => {
         const main = this.d.state.worktree(mainId);
         if (main)
           this.noteFetch(main.repoId, r);
@@ -29641,7 +30882,7 @@ class Trunk {
     if (Date.now() - last < OPEN_FETCH_MIN_MS)
       return;
     this.lastFetch.set(repo.path, Date.now());
-    const f = await run(GIT, ["fetch", "--quiet"], repo.path, NO_PROMPT);
+    const f = await withFetchLock(repo.path, () => run(GIT, ["fetch", "--quiet"], repo.path, NO_PROMPT));
     this.noteFetch(repo.id, f);
     if (!f.ok) {
       log.warn("fetch", `could not fetch ${repo.path}: ${f.err.slice(0, 200)}`);
@@ -29665,7 +30906,7 @@ class Trunk {
       return { ok: false, message: "no main checkout to pull" };
     this.lastFetch.set(repo.path, Date.now());
     w.step(`pulling ${repo.defaultBranch} from origin`);
-    const f = await w.git(repo.path, ["fetch", "--quiet"]);
+    const f = await withFetchLock(repo.path, () => w.git(repo.path, ["fetch", "--quiet"]));
     this.noteFetch(repo.id, f);
     if (!f.ok)
       return { ok: false, message: refused("fetch failed", f) };
@@ -29807,6 +31048,7 @@ function stopOf(prev, next) {
 // ../daemon/src/worktrees/service.ts
 var LOCAL_CONFIG_FILES = [".env", ".env.local", ".env.development", ".env.development.local", ".dev.vars"];
 var BASE_IGNORE = "base .gitignore";
+var REFUSAL_CHARS = 400;
 async function deleteTree(path) {
   try {
     await rm4(path, { recursive: true, force: true });
@@ -29867,10 +31109,9 @@ class WorktreeService {
         await this.discardWorktree(id);
       },
       carryDraft: (fromId, repoId) => {
-        const text = this.d.drafts?.text(fromId);
         const main = this.mainOf(repoId);
-        if (text && main)
-          this.d.drafts?.set(main.id, text);
+        if (main)
+          this.d.drafts?.move(fromId, main.id, true);
       },
       ready: (repoId) => {
         const main = this.mainOf(repoId);
@@ -29879,15 +31120,15 @@ class WorktreeService {
         if (this.d.runtime.get(main.id)?.procs) {
           fireAndForget(main.id, this.d.runtime.stopPage(main.id), "main's page stops for the spare");
         }
-        const text = this.d.drafts?.text(main.id);
         const spare = this.leadSpareOf(repoId);
-        if (text && spare && !this.d.drafts?.text(spare)) {
-          this.d.drafts?.set(spare, text);
-          this.d.drafts?.drop(main.id);
-        }
+        if (spare)
+          this.d.drafts?.move(main.id, spare);
       }
     });
     d.hub.on("agent", (worktreeId, _seq, event) => {
+      if ((event.type === "tool-start" || event.type === "tool-update" && event.kind) && isWriteTool({ name: event.name ?? "", kind: event.kind })) {
+        this.startPreview(worktreeId);
+      }
       if (event.type !== "usage")
         return;
       const { used, size, cost } = event;
@@ -29952,14 +31193,14 @@ class WorktreeService {
       rt.agent.send(agentPrompt, { context: withCarry(context, carried), attachments });
       this.scheduleNaming(claimed, task, variant);
       if (carried.unmoved)
-        throw new UserError(carried.unmoved);
+        throw new UserError(carried.unmoved, { delivered: true });
       return claimed;
     }
     if (!await isGitRepo(repo.path)) {
       throw new UserError(`git no longer reads ${repo.name} as a checkout, so there is nothing to start a worktree from. If \`git config core.bare\` says true there, \`git config --unset core.bare\` puts it back.`);
     }
-    const { id, dir } = freeSlot(join25(this.d.paths.worktreesDir, repo.name));
-    const wtPath = join25(this.d.paths.worktreesDir, repo.name, dir);
+    const { id, dir } = freeSlot(join27(this.d.paths.worktreesDir, repo.name));
+    const wtPath = join27(this.d.paths.worktreesDir, repo.name, dir);
     const branch = `toyon/${dir}`;
     await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--no-track", "-b", branch, wtPath, baseOf(repo)));
     const wt = {
@@ -29986,7 +31227,7 @@ class WorktreeService {
     this.d.runtime.ensureAgent(wt).agent.send(agentPrompt, { context: withCarry(context, carried), attachments });
     this.scheduleNaming(wt, task, variant);
     if (carried.unmoved)
-      throw new UserError(carried.unmoved);
+      throw new UserError(carried.unmoved, { delivered: true });
     return wt;
   }
   async carryMain(repo, wt, move) {
@@ -30025,7 +31266,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) => !existsSync28(join25(wt.path, p)));
+`).filter(Boolean) : []).filter((p) => !existsSync30(join27(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -30061,9 +31302,9 @@ class WorktreeService {
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
     let slug = branchSlug(title) || "branch";
-    if (existsSync28(join25(this.d.paths.worktreesDir, repo.name, slug)))
+    if (existsSync30(join27(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
-    const wtPath = join25(this.d.paths.worktreesDir, repo.name, slug);
+    const wtPath = join27(this.d.paths.worktreesDir, repo.name, slug);
     await withRepoLock(repo.path, async () => {
       const out = (await listWorktrees(repo.path)).find((w) => w.branch === branch);
       if (out)
@@ -30106,7 +31347,7 @@ class WorktreeService {
       throw new UserError("that worktree is gone, or Toyon already has it");
     return found;
   }
-  async adopt(worktreeId, createdBy) {
+  async adopt(worktreeId, createdBy, message) {
     const r = this.readable(worktreeId);
     if (!r)
       throw new UserError("that worktree is gone");
@@ -30135,12 +31376,18 @@ class WorktreeService {
         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;
     });
     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 });
     return wt;
   }
   async ownProcs(worktreeId, names) {
@@ -30283,7 +31530,7 @@ class WorktreeService {
       try {
         await this.removeDirectory(repo, wt);
       } catch (e) {
-        rmSync5(this.plansScratch(wt.id), { recursive: true, force: true });
+        rmSync7(this.plansScratch(wt.id), { recursive: true, force: true });
         throw e;
       }
       if (hasOwnBranch(wt)) {
@@ -30297,6 +31544,7 @@ class WorktreeService {
     this.d.state.removeWorktree(worktreeId);
     releasePort(wt.proxyPort);
     let archived = null;
+    await dropTurnRefs(repo.path, worktreeId);
     if (archive)
       archived = this.archiveChat(wt, repo, kept, sessionId, reason);
     else {
@@ -30309,7 +31557,7 @@ class WorktreeService {
   }
   async teardown(wt, repo) {
     const cmds = repo.config.teardown ?? [];
-    if (cmds.length === 0 || !existsSync28(wt.path))
+    if (cmds.length === 0 || !existsSync30(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") });
@@ -30318,7 +31566,7 @@ class WorktreeService {
     }
   }
   async keep(repo, wt) {
-    const index = join25(this.d.paths.archiveDir, `${wt.id}.index`);
+    const index = join27(this.d.paths.archiveDir, `${wt.id}.index`);
     const kept = await keepState(repo.path, wt.path, archiveRef(wt.id), index) ?? await this.keepUnlinked(repo, wt);
     if (!kept)
       log.warn(wt.id, "could not keep its git state");
@@ -30355,11 +31603,11 @@ class WorktreeService {
       log.warn(wt.id, `its directory could not be deleted and stays at ${wt.path}`);
   }
   plansScratch(worktreeId) {
-    return join25(this.d.paths.archiveDir, `${worktreeId}.plans`);
+    return join27(this.d.paths.archiveDir, `${worktreeId}.plans`);
   }
   keepPlans(wt) {
-    const from = join25(wt.path, PLANS_DIR);
-    if (!existsSync28(from))
+    const from = join27(wt.path, PLANS_DIR);
+    if (!existsSync30(from))
       return;
     try {
       cpSync(from, this.plansScratch(wt.id), { recursive: true });
@@ -30400,8 +31648,8 @@ class WorktreeService {
   deleteChat(worktreeId) {
     const files = this.chatFiles(worktreeId);
     try {
-      rmSync5(files.transcript, { force: true });
-      rmSync5(files.attachments, { recursive: true, force: true });
+      rmSync7(files.transcript, { force: true });
+      rmSync7(files.attachments, { recursive: true, force: true });
     } catch (e) {
       log.warn(worktreeId, "could not delete transcript or attachments", e);
     }
@@ -30447,7 +31695,7 @@ class WorktreeService {
   }
   archivedAttachment(archiveId, file) {
     const files = this.archive.chatFiles(archiveId);
-    return files && isAttachmentFile(file) ? join25(files.attachments, file) : null;
+    return files && isAttachmentFile(file) ? join27(files.attachments, file) : null;
   }
   archivedGit(archiveId) {
     const rec = this.archive.get(archiveId);
@@ -30490,7 +31738,7 @@ class WorktreeService {
       throw new UserError(`${old.title} was archived without its commits, so there is nothing to restore`);
     if (rec.auto)
       log.info(old.id, `restoring a worktree that archived itself (${rec.auto})`);
-    const path = existsSync28(old.path) ? join25(dirname11(old.path), freeSlot(dirname11(old.path)).dir) : old.path;
+    const path = existsSync30(old.path) ? join27(dirname11(old.path), freeSlot(dirname11(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`);
@@ -30524,10 +31772,11 @@ class WorktreeService {
       branch,
       proxyPort: await allocateProxyPort(),
       promptedAt: Date.now(),
+      parked: true,
       ...createdBy ? { createdBy } : {}
     };
     try {
-      this.archive.take(old.id, { ...this.chatFiles(old.id), plans: join25(path, PLANS_DIR) });
+      this.archive.take(old.id, { ...this.chatFiles(old.id), plans: join27(path, PLANS_DIR) });
     } catch (e) {
       log.warn(old.id, "could not move its chat back out of the archive", e);
     }
@@ -30556,12 +31805,12 @@ class WorktreeService {
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync28(repoPath)) {
+    if (rec.kept && existsSync30(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 && existsSync28(repoPath))
+    if (rec.worktree.lands?.length && existsSync30(repoPath))
       await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
     this.d.drafts?.drop(archiveId);
@@ -30652,6 +31901,15 @@ class WorktreeService {
     this.d.hub.emit("worktreesChanged");
     return { target, grafted: sources.map((w) => w.title) };
   }
+  startPreview(worktreeId) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt?.parked)
+      return;
+    delete wt.parked;
+    this.d.state.save();
+    this.d.hub.emit("worktreesChanged");
+    fireAndForget(worktreeId, this.d.runtime.wake(worktreeId), "start a parked preview");
+  }
   async setupAndStart(wt, repo, depsSource = repo.path, opts = {}) {
     this.d.runtime.markSetup(wt.id, true);
     try {
@@ -30661,9 +31919,9 @@ class WorktreeService {
     }
   }
   async mirrorBaseIgnore(repo) {
-    const src = join25(repo.path, ".gitignore");
-    const tracked = existsSync28(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
-    const mirror = existsSync28(src) && !tracked;
+    const src = join27(repo.path, ".gitignore");
+    const tracked = existsSync30(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
+    const mirror = existsSync30(src) && !tracked;
     const lines = mirror ? readFileSync18(src, "utf8").split(`
 `).filter((l) => l.trim() !== "") : [];
     await excludeBlock(repo.path, BASE_IGNORE, lines);
@@ -30676,9 +31934,9 @@ class WorktreeService {
       await this.d.cache.restore(wt, repo, (line) => this.d.hub.emit("log", wt.id, "setup", line));
       run.finish(0);
     }
-    const srcNm = join25(depsSource, "node_modules");
-    const dstNm = join25(wt.path, "node_modules");
-    if (existsSync28(srcNm) && !existsSync28(dstNm)) {
+    const srcNm = join27(depsSource, "node_modules");
+    const dstNm = join27(wt.path, "node_modules");
+    if (existsSync30(srcNm) && !existsSync30(dstNm)) {
       const r = await cloneTree(srcNm, dstNm);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `deps via ${r.how} in ${r.ms}ms`);
@@ -30686,10 +31944,10 @@ class WorktreeService {
         log.warn(wt.id, "could not copy node_modules from the base checkout", r.error);
     }
     for (const f of LOCAL_CONFIG_FILES) {
-      const src = join25(depsSource, f);
-      if (!existsSync28(src) || existsSync28(join25(wt.path, f)))
+      const src = join27(depsSource, f);
+      if (!existsSync30(src) || existsSync30(join27(wt.path, f)))
         continue;
-      const r = await run("cp", [src, join25(wt.path, f)], wt.path);
+      const r = await run("cp", [src, join27(wt.path, f)], wt.path);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `copied ${f}`);
       else
@@ -30820,13 +32078,15 @@ ${wt.landing.body}` : s;
         const handle = commit ? this.runs.begin(wt.id, "commit", { timeoutMs: ceiling }) : null;
         const run = (onText, signal) => stepRun(cwd, args, onText, signal, {
           timeoutMs: ceiling,
-          ...handle ? { onSpawn: handle.spawned, onHook: (hook) => handle.stage(hook ? `${hook} hook` : undefined) } : {}
+          ...handle ? { onSpawn: handle.spawned } : {},
+          onHook: (hook) => handle?.stage(hook ? `${hook} hook` : undefined)
         });
         const watched = async () => {
           if (!this.d.watch)
             return run(() => {});
+          const command = `${where} ${commandLine(args)}`;
           try {
-            return await this.d.watch(wt.id, `${where} ${commandLine(args)}`, run);
+            return { ...await this.d.watch(wt.id, command, run), command };
           } catch (e) {
             log.warn(wt.id, `landing step runs unwatched: ${e instanceof Error ? e.message : e}`);
             return run(() => {});
@@ -30864,7 +32124,35 @@ ${wt.landing.body}` : s;
     });
     if (out.result.ok && out.archiveIds)
       this.noteLanded(wt, out.result.message, out.archiveIds);
-    return out;
+    return { ...out, result: this.fixShip(wt, out.result, baseOf(repo)) };
+  }
+  fixShip(wt, result, base) {
+    if (result.ok)
+      return result;
+    if (result.hook?.name === "commit-msg") {
+      this.d.hub.emit("messageRefused", wt.id, result.hook.text.trim().slice(-REFUSAL_CHARS));
+      return { ...result, message: "the commit-msg hook refused the message: another is being written" };
+    }
+    const { hook } = result;
+    const failure = hook ? { kind: "hook", hook: hook.name, toolId: hook.toolId, command: hook.command, text: hook.text } : result.conflict ? { kind: "conflict", base, how: result.conflict, ...result.step ? { step: result.step } : {} } : null;
+    return failure && this.d.fix.report(wt.id, failure) ? { ...result, asked: true } : result;
+  }
+  async fixPreview(worktreeId, clientId) {
+    const wt = this.d.state.requireWorktree(worktreeId);
+    const failure = {
+      kind: "preview",
+      procs: this.d.runtime.get(worktreeId)?.procs?.states() ?? [],
+      log: this.d.runtime.recentLogs(worktreeId)
+    };
+    if (!isLead(wt)) {
+      if (!this.d.fix.report(worktreeId, failure, { pressed: true }))
+        throw new UserError("worktree still starting; try again in a moment");
+      return;
+    }
+    await this.create(wt.repoId, fixPrompt(failure), {
+      ...clientId ? { createdBy: clientId } : {},
+      ...isProvisional(wt) ? { worktreeId } : {}
+    });
   }
   async movedMidTurn(wt) {
     const status = this.d.runtime.agentFor(wt.id)?.status;
@@ -30993,11 +32281,14 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       if (committed && !committed.ok)
         return committed;
       committedHere = committed !== null;
+      const method = policy.merge ?? DEFAULT_MERGE_METHOD;
+      const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
+      if (merged)
+        return merged;
       const taken = await takeMainIn(wt.path, base, own, w);
       if (!taken.ok)
         return taken;
       const mark = await landingMark(wt.path, base);
-      const method = policy.merge ?? DEFAULT_MERGE_METHOD;
       const squash = method === "squash" ? await squashMessage(wt.path, base, suggested) : "";
       const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash, w);
       if (!landed.ok)
@@ -31028,6 +32319,9 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       return { result: { ok: false, message: `nothing to land: no commits ahead of ${base}` } };
     let sha = "";
     let already = false;
+    const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
+    if (merged)
+      return { result: merged };
     for (let attempt = 0;; attempt++) {
       const fetched = await this.fetchBase(wt, repo, w);
       if (!fetched.ok)
@@ -31097,7 +32391,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   async fetchBase(wt, repo, w) {
     if (!baseIsRemote(repo))
       return { ok: true, message: `${baseOf(repo)} here is the base` };
-    const r = await fetchBase(wt.path, repo, w);
+    const r = await withFetchLock(repo.path, () => fetchBase(wt.path, repo, w));
     this.trunk.noteFetch(repo.id, { ok: r.ok, err: r.message });
     return r;
   }
@@ -31165,7 +32459,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       }
       return taken;
     });
-    return { result, base: r.base };
+    return { result: r.wt ? this.fixShip(r.wt, result, r.base) : result, base: r.base };
   }
   async pull(worktreeId) {
     const wt = this.d.state.requireWorktree(worktreeId);
@@ -31187,7 +32481,8 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const m = message.trim();
     if (!m)
       throw new UserError("commit message required");
-    return this.ship(wt.id, "commit", () => this.commitRecorded(wt, m));
+    const base = baseOf(this.d.state.requireRepo(wt.repoId));
+    return this.fixShip(wt, await this.ship(wt.id, "commit", () => this.commitRecorded(wt, m)), base);
   }
   setEmpty(wt, empty) {
     if (wt.empty === empty)
@@ -31333,6 +32628,11 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       base: baseOf(repo)
     };
   }
+  async turnStarted(worktreeId) {
+    const wt = this.d.state.worktree(worktreeId);
+    if (wt && !this.going.has(worktreeId))
+      await markTurn(wt.path, wt.id);
+  }
   async gitStatus(worktreeId) {
     if (this.going.has(worktreeId))
       return null;
@@ -31353,6 +32653,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       const counts = { ...ab, ...unpushed === undefined ? {} : { unpushed } };
       const ahead = counts.ahead ?? 0;
       const committed = !isMain && ahead > 0 ? await committedFiles(r.path, r.base) : undefined;
+      const turn = r.wt && files.length > 0 ? await turnChanges(r.path, r.wt.id, r.base, !isMain, files) : null;
       if (r.wt && !isMain && hasOwnBranch(r.wt) && files.length === 0 && ahead === 0 && head.ok && this.handChecked.get(r.wt.id) !== head.out) {
         this.handChecked.set(r.wt.id, head.out);
         const mark = await handLanding(r.path, r.wt.branch, r.base, r.wt.lands?.at(-1)?.tip);
@@ -31379,7 +32680,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       if (this.going.has(worktreeId))
         return null;
       this.noteCounts(worktreeId, isMain, files.length, counts);
-      return { files, committed, head: head.ok ? head.out : undefined, ...counts };
+      return { files, committed, ...turn ? { turn } : {}, head: head.ok ? head.out : undefined, ...counts };
     } catch (e) {
       log.warn(worktreeId, "git status failed", e);
       return null;
@@ -31648,7 +32949,8 @@ var accounts = new AgentAccounts({
   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 attachments2 = new AttachmentStore(paths.attachmentsDir);
+var uploads = new UploadStore(paths.uploadsDir);
+var attachments2 = new AttachmentStore(paths.attachmentsDir, uploads);
 var runtime = new RuntimeRegistry({
   hub,
   state,
@@ -31658,16 +32960,23 @@ var runtime = new RuntimeRegistry({
   accounts,
   attachments: attachments2,
   bridgeScript: () => bridge.get(),
+  turnStarting: (id) => worktrees.turnStarted(id),
   remote,
   grant: previewGrant(token),
   viewed: (id) => idle.isViewed(id),
   shown: (id) => idle.isShown(id),
   mainLeads: (repoId) => worktrees.spare.current(repoId) === null
 });
-var drafts = new DraftStore({ file: paths.draftsFile, hub });
+var drafts = new DraftStore({
+  file: paths.draftsFile,
+  attachmentsFile: paths.draftAttachmentsFile,
+  hub,
+  uploads
+});
 var runs = new RunService({ state, hub });
 var exec = new ExecService({ state, runtime, shipping: (id) => worktrees.shippingOf(id) });
 var cache = new ArtifactCache({ paths, state, hub });
+var fix = new FixService({ state, hub, runtime });
 var worktrees = new WorktreeService({
   state,
   hub,
@@ -31677,7 +32986,8 @@ var worktrees = new WorktreeService({
   drafts,
   cache,
   watch: (id, command, run) => exec.watch(id, command, run),
-  runs
+  runs,
+  fix
 });
 new BackendShare({ state, hub, runtime, own: (id, names) => worktrees.ownProcs(id, names) });
 var turns = new TurnService({
@@ -31777,6 +33087,13 @@ var idleExit = new IdleExit({
   },
   afterMs: stopAfter
 });
+var keepAwake = new KeepAwake({
+  hub,
+  demand: () => runtime.demand(),
+  assert: idleSleepAssertion(process.env.TOYON_KEEP_AWAKE),
+  mode: () => state.keepAwake,
+  answerable: remote !== null
+});
 var { branded, stop: stopServer } = startServer({
   port,
   token,
@@ -31798,6 +33115,7 @@ var { branded, stop: stopServer } = startServer({
     runtime,
     idle,
     idleExit,
+    keepAwake,
     exec,
     runs,
     refs,
@@ -31805,6 +33123,7 @@ var { branded, stop: stopServer } = startServer({
     drafts,
     prs,
     landing,
+    fix,
     themes,
     agents,
     accounts,
@@ -31834,6 +33153,7 @@ var stopLagSampler = startLagSampler();
 await runtime.reclaimOrphans();
 await repos.boot();
 drafts.prune((id) => !!state.worktree(id) || worktrees.hasArchived(id));
+uploads.sweep(drafts.uploadIds());
 idle.boot();
 runs.boot();
 landing.boot();
@@ -31876,6 +33196,7 @@ async function shutdown(signal, opts = {}) {
   shuttingDown = true;
   log.info("daemon", `${signal}: stopping dev servers`);
   idleExit.stop();
+  keepAwake.stop();
   idle.shutdown();
   landing.stop();
   runs.stopWatching();
@@ -31889,7 +33210,7 @@ async function shutdown(signal, opts = {}) {
   const deadline = new Promise((resolve) => setTimeout(resolve, 5000));
   await Promise.race([Promise.all([runtime.shutdown(), exec.stopAll()]), deadline]);
   state.flushGroups();
-  rmSync6(paths.pidFile, { force: true });
+  rmSync8(paths.pidFile, { force: true });
   if (opts.respawn) {
     await Bun.sleep(250);
     log.info("daemon", "starting the replacement");