toyon 0.8.1 → 0.9.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";
 
@@ -120,8 +120,9 @@ function archiveReason(wt, f) {
   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)}`;
+  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 +158,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) {
@@ -6469,12 +6478,15 @@ var PAIR_TTL_MS = 120000;
 var pairLink = (host, code) => `https://${host}/#pair=${code}`;
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 83;
+var PROTOCOL_VERSION = 85;
 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 +6571,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 +6593,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 +6608,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 +6726,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 +6736,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 +6745,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 +6753,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 +6762,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,7 +6777,8 @@ 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({
@@ -6760,7 +6787,14 @@ var clientMsgSchema = discriminatedUnion("t", [
     worktreeId: id
   }),
   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 }),
@@ -6801,12 +6835,24 @@ var clientMsgSchema = discriminatedUnion("t", [
   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({
@@ -6870,6 +6916,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 +8201,7 @@ function safeUser() {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.8.1",
+  version: "0.9.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -12248,9 +12295,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 +12552,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 +12731,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 +12774,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 +12803,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 +13031,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 +13060,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 +13102,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");
@@ -13142,7 +13417,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 +13440,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 +13510,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 +13572,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 +13598,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 +13665,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 +13679,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 +13702,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 +13827,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 +13840,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 +13894,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 +13921,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 {
@@ -13906,6 +14184,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: this worktree came back from the archive, and Toyon starts its dev servers 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 +14201,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 +14252,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 +14260,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 +14275,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 +14432,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 +14445,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 +14813,26 @@ 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 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) {
+      const sent = release(toolId, memo);
+      if (sent)
+        out.push(sent);
+      continue;
+    }
     memo.ended = true;
     out.push({ type: "tool-end", toolId });
   }
@@ -14554,7 +14861,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 +14916,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 +15084,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 };
@@ -14891,7 +15204,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 +15213,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 +15243,14 @@ class AcpSession {
   send(text, opts = {}) {
     if (this.stopped)
       return log.warn(this.d.worktreeId, "send after close dropped");
+    for (const ask of [...this.asks.values()])
+      ask.settle("skipped");
+    this.post(text, opts);
+  }
+  post(text, opts = {}) {
     const { context, attachments } = opts;
     const item = { text, context, ...attachments?.length ? { 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");
     }
@@ -15012,6 +15337,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 +15462,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 +15486,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 +15513,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);
@@ -15410,6 +15746,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 +15758,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 || !(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 +15833,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 +16028,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 +16039,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 +16047,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 +16062,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 +17367,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),
@@ -17318,9 +17676,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 +18080,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 +18149,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 };
   }
 }
@@ -18133,6 +18499,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 +18575,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,7 +18610,7 @@ 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 {}
   }
@@ -18894,7 +19262,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 +19324,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;
 }
@@ -19170,7 +19538,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 +19988,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 +20103,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 +20116,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 +20153,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 +20222,8 @@ class DraftStore {
     this.saveTimer = null;
     this.write();
   }
-  scheduleSave() {
+  scheduleSave(which) {
+    this.dirty[which] = true;
     if (this.saveTimer)
       return;
     this.saveTimer = setTimeout(() => {
@@ -19815,13 +20233,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);
   }
 }
 
@@ -20050,17 +20486,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 +20507,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 +20524,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 +20549,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 };
@@ -20151,7 +20587,7 @@ function looksBinary(text) {
 
 // ../daemon/src/files/service.ts
 import { spawn as spawn4 } from "child_process";
-import { stat, unlink } from "fs/promises";
+import { stat as stat2, unlink } from "fs/promises";
 
 // ../daemon/src/git/blame.ts
 var NONE = { commits: [], lines: [] };
@@ -20222,10 +20658,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 +20674,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 +20707,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 +20729,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 +20902,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 +20915,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 +21086,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 +21147,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 };
@@ -20890,7 +21333,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 +21612,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 +21625,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 +22990,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 +23015,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 +23074,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 +23092,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 +23122,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 +23145,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 +23188,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 +23215,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 +23278,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 +23306,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 +23317,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 +23358,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 +23369,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 +23393,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 +23504,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 +23541,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 +23594,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 +23616,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 +23645,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 +23688,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 +23825,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 +23976,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 +23988,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 +24092,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 +24184,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 +25384,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 +25409,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 +25731,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 +25739,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 +25750,13 @@ class PairCodes {
   }
 }
 
+// ../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 +25766,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 +26427,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 +26442,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 +26461,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 +26507,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,8 +26532,10 @@ 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);
@@ -26072,10 +26547,17 @@ var handlers = {
     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))
@@ -26188,7 +26670,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);
@@ -26388,6 +26884,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 +26900,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 +26949,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;
@@ -26561,6 +27092,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 +27133,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 +27163,14 @@ 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) {
       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,6 +27182,22 @@ 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;
@@ -26843,6 +27423,7 @@ function startServer(opts) {
   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 {
@@ -26869,11 +27450,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,
@@ -26901,7 +27484,6 @@ function startServer(opts) {
       }
     }),
     websocket: {
-      maxPayloadLength: 64 * 1024 * 1024,
       async open(ws) {
         const preview = ws.data.preview;
         if (preview) {
@@ -26943,7 +27525,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 +27592,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 +27685,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 +27717,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 +27741,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 +27757,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 +28173,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 +28205,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 +28218,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 +28233,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 +28264,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 +28272,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 +28313,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 +28329,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 +28371,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 +28383,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 +28392,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 +28412,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)");
       }
@@ -28660,12 +29242,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 existsSync29, 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 +29290,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) {
@@ -29183,18 +29765,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 existsSync26, 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 (!existsSync26(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 (!existsSync26(index)) {
+    const own = join24(index, "..", "index");
+    if (existsSync26(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 existsSync27, 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 (!existsSync27(file))
         continue;
       try {
         this.records.set(id, JSON.parse(readFileSync17(file, "utf8")));
@@ -29208,7 +29914,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 +29934,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 +29949,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 (!existsSync27(file))
       return null;
     try {
       return readFileSync17(file, "utf8");
@@ -29254,13 +29960,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 +29991,7 @@ function summarize(r, repoId, transcript) {
   };
 }
 function lastUsage(transcript) {
-  if (!existsSync26(transcript))
+  if (!existsSync27(transcript))
     return null;
   const lines = readFileSync17(transcript, "utf8").split(`
 `);
@@ -29301,7 +30007,7 @@ function lastUsage(transcript) {
   return null;
 }
 function firstPrompt(transcript) {
-  if (!existsSync26(transcript))
+  if (!existsSync27(transcript))
     return;
   for (const line of readFileSync17(transcript, "utf8").split(`
 `)) {
@@ -29316,10 +30022,10 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync26(from))
+  if (!existsSync27(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 +30087,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 existsSync28 } from "fs";
+import { basename as basename9, join as join26 } from "path";
 class SparePool {
   d;
   inflight = new Map;
@@ -29401,7 +30107,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" || !existsSync28(wt.path))
       return;
     const agent = this.d.runtime.ensureAgent(wt).agent;
     if (agent.runningAgent === null)
@@ -29446,11 +30152,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 +30171,7 @@ class SparePool {
     const repoId = repo.id;
     let cut = () => {};
     const added = (async () => {
-      if (existsSync27(wt.path))
+      if (existsSync28(wt.path))
         return;
       await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--detach", wt.path, baseOf(repo)));
     })();
@@ -29513,7 +30219,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 (existsSync28(wt.path)) {
       await this.d.discard(wt.id).catch((re) => log.warn(wt.repoId, "spare rollback failed", re));
       return;
     }
@@ -29570,7 +30276,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" || !existsSync28(wt.path))
         return null;
     }
     await this.refreshing.get(repoId);
@@ -29616,7 +30322,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 +30347,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 +30371,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) };
@@ -29867,10 +30573,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 +30584,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 +30657,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 +30691,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 +30730,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) => !existsSync29(join27(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -30061,9 +30766,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 (existsSync29(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)
@@ -30283,7 +30988,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 +31002,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 +31015,7 @@ class WorktreeService {
   }
   async teardown(wt, repo) {
     const cmds = repo.config.teardown ?? [];
-    if (cmds.length === 0 || !existsSync28(wt.path))
+    if (cmds.length === 0 || !existsSync29(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 +31024,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 +31061,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 (!existsSync29(from))
       return;
     try {
       cpSync(from, this.plansScratch(wt.id), { recursive: true });
@@ -30400,8 +31106,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 +31153,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 +31196,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 = existsSync29(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 +31230,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 +31263,12 @@ class WorktreeService {
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync28(repoPath)) {
+    if (rec.kept && existsSync29(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 && existsSync29(repoPath))
       await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
     this.d.drafts?.drop(archiveId);
@@ -30652,6 +31359,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 +31377,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 = existsSync29(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
+    const mirror = existsSync29(src) && !tracked;
     const lines = mirror ? readFileSync18(src, "utf8").split(`
 `).filter((l) => l.trim() !== "") : [];
     await excludeBlock(repo.path, BASE_IGNORE, lines);
@@ -30676,9 +31392,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 (existsSync29(srcNm) && !existsSync29(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 +31402,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 (!existsSync29(src) || existsSync29(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
@@ -31097,7 +31813,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;
   }
@@ -31333,6 +32049,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 +32074,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 +32101,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 +32370,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,13 +32381,19 @@ 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 });
@@ -31834,6 +32563,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();
@@ -31889,7 +32619,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");