@paradow/ledge 0.19.1 → 0.21.0

package/dist/cli/{chunk-HP3G2TYJ.js → chunk-EX66KH66.js}

@@ -1,6 +1,6 @@
 import {
   paths
-} from "./chunk-7ZAA75HG.js";
+} from "./chunk-HOOHS3MX.js";
 
 // ../protocol/src/handover.ts
 import { z } from "zod";
@@ -164,6 +164,19 @@ import { z as z3 } from "zod";
 var TASK_TITLE_MAX = 200;
 var TASK_TEXT_MAX = 2e4;
 var LEDGE_GIVER = "ledge";
+var TASK_OPS = ["give", "take", "pass", "done", "refuse", "cancel", "drop"];
+var TRANSMISSION_OPS = ["give", "pass", "done", "refuse", "cancel"];
+var TaskLogEntrySchema = z3.object({
+  at: z3.string(),
+  by: z3.string(),
+  what: z3.string(),
+  op: z3.enum(TASK_OPS).optional(),
+  from: z3.string().optional(),
+  to: z3.string().optional(),
+  fromName: z3.string().optional(),
+  toName: z3.string().optional(),
+  note: z3.string().optional()
+});
 var TaskSchema = z3.object({
   id: z3.string(),
   title: z3.string(),
@@ -180,8 +193,12 @@ var TaskSchema = z3.object({
   seen: z3.boolean().optional(),
   at: z3.string(),
   updatedAt: z3.string(),
-  log: z3.array(z3.object({ at: z3.string(), by: z3.string(), what: z3.string() }))
+  log: z3.array(TaskLogEntrySchema)
 });
+var handOver = (op) => TRANSMISSION_OPS.includes(op ?? "");
+function transmissions(t) {
+  return t.log.flatMap((e, index) => handOver(e.op) && e.from !== void 0 && e.to !== void 0 ? [{ index, at: e.at, op: e.op, from: e.from, to: e.to, fromName: e.fromName ?? "", toName: e.toName ?? "", ...e.note !== void 0 ? { note: e.note } : {} }] : []);
+}
 var givenByLedge = (t) => t.giver === LEDGE_GIVER;
 var taskClosed = (t) => t.state === "done" || t.state === "refused" || t.state === "dropped";
 var TaskCmdSchema = z3.object({
@@ -208,170 +225,205 @@ var TaskResultSchema = z3.object({
 });
 
 // ../protocol/src/messages.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // ../protocol/src/chat.ts
+import { z as z5 } from "zod";
+
+// ../protocol/src/attachments.ts
 import { z as z4 } from "zod";
-var ChatStepSchema = z4.object({
-  kind: z4.enum(["sessions", "pane", "reply", "git", "repo"]),
-  id: z4.string().optional(),
-  name: z4.string().optional(),
-  path: z4.string().optional()
+var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
+var AttachmentIdSchema = z4.string().regex(ATTACHMENT_ID);
+var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
+var ImageMimeSchema = z4.enum(IMAGE_MIMES);
+var ATTACHMENT_MAX = 4e5;
+var ATTACHMENT_LOCAL_MAX = 2e6;
+var PREVIEW_MAX = 4e4;
+var ATTACHMENTS_MAX = 5;
+var b64Max = (bytes) => Math.ceil(bytes / 3) * 4;
+var AttachmentRefSchema = z4.object({
+  id: AttachmentIdSchema,
+  mime: ImageMimeSchema,
+  width: z4.number().int().positive(),
+  height: z4.number().int().positive(),
+  bytes: z4.number().int().positive(),
+  preview: z4.boolean()
 });
-var ChatProposalSchema = z4.object({
-  cwd: z4.string().min(1),
-  project: z4.string(),
-  prompt: z4.string().optional(),
+var ImageUploadSchema = z4.object({
+  mime: ImageMimeSchema,
+  data: z4.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
+  preview: z4.object({ mime: ImageMimeSchema, data: z4.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
+});
+var AttachmentErrorReasonSchema = z4.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
+var requestId = z4.string().min(1).max(100);
+var AttachmentPutSchema = z4.object({ type: z4.literal("attachment.put"), requestId, id: z4.string().optional(), image: ImageUploadSchema });
+var AttachmentGetSchema = z4.object({ type: z4.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z4.boolean().optional(), id: z4.string().optional(), machine: z4.string().optional() });
+var AttachmentStoredSchema = z4.object({ type: z4.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
+var AttachmentDataSchema = z4.object({ type: z4.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z4.string() });
+var AttachmentErrorSchema = z4.object({ type: z4.literal("attachment.error"), requestId, reason: AttachmentErrorReasonSchema });
+
+// ../protocol/src/chat.ts
+var ChatStepSchema = z5.object({
+  kind: z5.enum(["sessions", "pane", "reply", "git", "repo"]),
+  id: z5.string().optional(),
+  name: z5.string().optional(),
+  path: z5.string().optional()
+});
+var ChatProposalSchema = z5.object({
+  cwd: z5.string().min(1),
+  project: z5.string(),
+  prompt: z5.string().optional(),
   tool: ToolSchema,
-  launchedId: z4.string().optional(),
-  error: z4.string().optional()
+  launchedId: z5.string().optional(),
+  error: z5.string().optional()
 });
 var MAX_PROPOSALS = 8;
-var ChatProposalsSchema = z4.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatRelaySchema = z4.object({
-  id: z4.string().min(1),
-  name: z4.string(),
+var ChatProposalsSchema = z5.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatRelaySchema = z5.object({
+  id: z5.string().min(1),
+  name: z5.string(),
   tool: ToolSchema,
-  text: z4.string().min(1),
-  status: z4.enum(["queued", "sent"]).optional(),
-  sentAt: z4.string().datetime().optional(),
-  error: z4.string().optional()
+  text: z5.string().min(1),
+  status: z5.enum(["queued", "sent"]).optional(),
+  sentAt: z5.string().datetime().optional(),
+  error: z5.string().optional()
 });
-var ChatCloseSchema = z4.object({
-  id: z4.string().min(1),
-  name: z4.string(),
+var ChatCloseSchema = z5.object({
+  id: z5.string().min(1),
+  name: z5.string(),
   tool: ToolSchema,
-  closedAt: z4.string().datetime().optional(),
-  how: z4.enum(["exit", "killed"]).optional(),
-  error: z4.string().optional()
+  closedAt: z5.string().datetime().optional(),
+  how: z5.enum(["exit", "killed"]).optional(),
+  error: z5.string().optional()
 });
-var ChatClosesSchema = z4.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
-var ChatProjectProposalSchema = z4.object({
-  name: z4.string().min(1).max(80),
-  description: z4.string().max(500).optional(),
-  repos: z4.array(z4.object({ path: z4.string().min(1).max(4096), why: z4.string().min(1).max(200) })).min(1).max(50),
-  addTo: z4.string().min(1).max(80).optional()
+var ChatClosesSchema = z5.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
+var ChatProjectProposalSchema = z5.object({
+  name: z5.string().min(1).max(80),
+  description: z5.string().max(500).optional(),
+  repos: z5.array(z5.object({ path: z5.string().min(1).max(4096), why: z5.string().min(1).max(200) })).min(1).max(50),
+  addTo: z5.string().min(1).max(80).optional()
 });
-var ChatTeamSeatSchema = z4.object({
-  role: z4.string().min(1),
-  label: z4.string(),
+var ChatTeamSeatSchema = z5.object({
+  role: z5.string().min(1),
+  label: z5.string(),
   tool: ToolSchema,
-  model: z4.string().optional(),
-  effort: z4.string().optional(),
+  model: z5.string().optional(),
+  effort: z5.string().optional(),
   autonomy: AutonomySchema.optional(),
-  name: z4.string().optional()
+  name: z5.string().optional()
 });
-var ChatTeamProposalSchema = z4.object({
-  cwd: z4.string().min(1),
-  project: z4.string(),
-  projectName: z4.string().optional(),
-  name: z4.string().min(1),
-  template: z4.string().optional(),
-  seats: z4.array(ChatTeamSeatSchema).min(1).max(8),
-  teamId: z4.string().optional(),
-  launchedAt: z4.string().datetime().optional(),
-  error: z4.string().optional(),
-  savedPath: z4.string().optional()
+var ChatTeamProposalSchema = z5.object({
+  cwd: z5.string().min(1),
+  project: z5.string(),
+  projectName: z5.string().optional(),
+  name: z5.string().min(1),
+  template: z5.string().optional(),
+  seats: z5.array(ChatTeamSeatSchema).min(1).max(8),
+  teamId: z5.string().optional(),
+  launchedAt: z5.string().datetime().optional(),
+  error: z5.string().optional(),
+  savedPath: z5.string().optional()
 });
-var ChatTaskProposalSchema = z4.object({
-  to: z4.string().min(1),
-  toName: z4.string().optional(),
-  team: z4.string().optional(),
-  title: z4.string().min(1).max(200),
-  text: z4.string().max(2e4).optional(),
-  taskId: z4.string().optional(),
-  ownerName: z4.string().optional(),
-  state: z4.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  givenAt: z4.string().datetime().optional(),
-  error: z4.string().optional()
+var ChatTaskProposalSchema = z5.object({
+  to: z5.string().min(1),
+  toName: z5.string().optional(),
+  team: z5.string().optional(),
+  title: z5.string().min(1).max(200),
+  text: z5.string().max(2e4).optional(),
+  taskId: z5.string().optional(),
+  ownerName: z5.string().optional(),
+  state: z5.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  givenAt: z5.string().datetime().optional(),
+  error: z5.string().optional()
 });
-var ChatTasksSchema = z4.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatTurnSchema = z4.object({
-  machineId: z4.string().optional(),
-  machineName: z4.string().optional(),
-  choices: z4.array(z4.object({ id: z4.string(), label: z4.string() })).optional(),
-  qid: z4.string().min(1),
-  question: z4.string(),
-  askedAt: z4.string().datetime(),
-  steps: z4.array(ChatStepSchema),
-  answer: z4.string().optional(),
-  answeredAt: z4.string().datetime().optional(),
-  error: z4.string().optional(),
+var ChatTasksSchema = z5.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatTurnSchema = z5.object({
+  machineId: z5.string().optional(),
+  machineName: z5.string().optional(),
+  choices: z5.array(z5.object({ id: z5.string(), label: z5.string() })).optional(),
+  qid: z5.string().min(1),
+  question: z5.string(),
+  askedAt: z5.string().datetime(),
+  steps: z5.array(ChatStepSchema),
+  answer: z5.string().optional(),
+  answeredAt: z5.string().datetime().optional(),
+  error: z5.string().optional(),
   proposal: ChatProposalSchema.optional(),
   proposals: ChatProposalsSchema.optional(),
   relay: ChatRelaySchema.optional(),
   closes: ChatClosesSchema.optional(),
   projectProposal: ChatProjectProposalSchema.optional(),
   team: ChatTeamProposalSchema.optional(),
-  tasks: ChatTasksSchema.optional()
+  tasks: ChatTasksSchema.optional(),
+  attachments: z5.array(AttachmentRefSchema).optional()
 });
 var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
 
 // ../protocol/src/repos.ts
-import { z as z5 } from "zod";
-var ReposInspectSchema = z5.object({
-  type: z5.literal("repos.inspect"),
-  requestId: z5.string().min(1).max(100),
-  paths: z5.array(z5.string().min(1)).min(1).max(50),
-  machineId: z5.string().optional()
+import { z as z6 } from "zod";
+var ReposInspectSchema = z6.object({
+  type: z6.literal("repos.inspect"),
+  requestId: z6.string().min(1).max(100),
+  paths: z6.array(z6.string().min(1)).min(1).max(50),
+  machineId: z6.string().optional()
 });
-var RepoInfoSchema = z5.object({ path: z5.string(), exists: z5.boolean(), branch: z5.string().nullable() });
-var ReposInfoSchema = z5.object({ type: z5.literal("repos.info"), requestId: z5.string(), repos: z5.array(RepoInfoSchema) });
+var RepoInfoSchema = z6.object({ path: z6.string(), exists: z6.boolean(), branch: z6.string().nullable() });
+var ReposInfoSchema = z6.object({ type: z6.literal("repos.info"), requestId: z6.string(), repos: z6.array(RepoInfoSchema) });
 
 // ../protocol/src/models.ts
-import { z as z6 } from "zod";
-var ModelIdSchema = z6.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
-var EffortSchema = z6.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
-var ModelChoiceSchema = z6.object({
+import { z as z7 } from "zod";
+var ModelIdSchema = z7.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
+var EffortSchema = z7.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
+var ModelChoiceSchema = z7.object({
   id: ModelIdSchema,
-  label: z6.string(),
-  description: z6.string().optional(),
-  efforts: z6.array(EffortSchema).optional(),
+  label: z7.string(),
+  description: z7.string().optional(),
+  efforts: z7.array(EffortSchema).optional(),
   defaultEffort: EffortSchema.optional(),
-  isDefault: z6.boolean().optional()
+  isDefault: z7.boolean().optional()
 });
-var ModelsListSchema = z6.object({
-  type: z6.literal("models.list"),
-  requestId: z6.string().min(1).max(100),
+var ModelsListSchema = z7.object({
+  type: z7.literal("models.list"),
+  requestId: z7.string().min(1).max(100),
   tool: ToolSchema,
-  machineId: z6.string().optional()
+  machineId: z7.string().optional()
 });
-var ModelsListingSchema = z6.object({
-  type: z6.literal("models.listing"),
-  requestId: z6.string(),
+var ModelsListingSchema = z7.object({
+  type: z7.literal("models.listing"),
+  requestId: z7.string(),
   tool: ToolSchema,
-  models: z6.array(ModelChoiceSchema),
-  error: z6.string().optional()
+  models: z7.array(ModelChoiceSchema),
+  error: z7.string().optional()
 });
 
 // ../protocol/src/scan.ts
-import { z as z7 } from "zod";
-var ReposScanSchema = z7.object({ type: z7.literal("repos.scan"), requestId: z7.string().min(1).max(100), machineId: z7.string().optional() });
-var FoundRepoSchema = z7.object({ path: z7.string(), branch: z7.string().nullable(), remote: z7.string().optional(), manifest: z7.string().max(200).optional() });
-var ReposFoundSchema = z7.object({ type: z7.literal("repos.found"), requestId: z7.string(), repos: z7.array(FoundRepoSchema).max(500), truncated: z7.boolean(), error: z7.string().optional() });
+import { z as z8 } from "zod";
+var ReposScanSchema = z8.object({ type: z8.literal("repos.scan"), requestId: z8.string().min(1).max(100), machineId: z8.string().optional() });
+var FoundRepoSchema = z8.object({ path: z8.string(), branch: z8.string().nullable(), remote: z8.string().optional(), manifest: z8.string().max(200).optional() });
+var ReposFoundSchema = z8.object({ type: z8.literal("repos.found"), requestId: z8.string(), repos: z8.array(FoundRepoSchema).max(500), truncated: z8.boolean(), error: z8.string().optional() });
 
 // ../protocol/src/documents.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var DOCUMENT_MAX_BYTES = 1048576;
-var path = z8.string().min(1).max(4096);
-var requestId = z8.string().min(1);
-var DocumentReadSchema = z8.object({
-  type: z8.literal("document.read"),
-  requestId,
+var path = z9.string().min(1).max(4096);
+var requestId2 = z9.string().min(1);
+var DocumentReadSchema = z9.object({
+  type: z9.literal("document.read"),
+  requestId: requestId2,
   path,
-  machineId: z8.string().optional(),
-  sessionId: z8.string().min(1).optional(),
+  machineId: z9.string().optional(),
+  sessionId: z9.string().min(1).optional(),
   basePath: path.optional()
 });
-var DocumentContentSchema = z8.object({
-  type: z8.literal("document.content"),
-  requestId,
+var DocumentContentSchema = z9.object({
+  type: z9.literal("document.content"),
+  requestId: requestId2,
   path,
-  text: z8.string(),
-  bytes: z8.number().int().nonnegative(),
-  modifiedAt: z8.string().datetime()
+  text: z9.string(),
+  bytes: z9.number().int().nonnegative(),
+  modifiedAt: z9.string().datetime()
 });
-var DocumentErrorCodeSchema = z8.enum([
+var DocumentErrorCodeSchema = z9.enum([
   "not_found",
   "not_file",
   "unsupported_path",
@@ -383,47 +435,47 @@ var DocumentErrorCodeSchema = z8.enum([
   "session_missing",
   "read_failed"
 ]);
-var DocumentErrorSchema = z8.object({
-  type: z8.literal("document.error"),
-  requestId,
+var DocumentErrorSchema = z9.object({
+  type: z9.literal("document.error"),
+  requestId: requestId2,
   path,
   code: DocumentErrorCodeSchema
 });
 
 // ../protocol/src/routing.ts
-import { z as z9 } from "zod";
-var MachineInventorySchema = z9.object({
-  id: z9.string().min(1).max(80),
-  label: z9.string().min(1).max(120),
-  online: z9.boolean(),
-  local: z9.boolean(),
-  sessions: z9.array(z9.object({ id: z9.string(), name: z9.string(), project: z9.string(), cwd: z9.string(), topic: z9.string().optional(), state: z9.string(), readOnly: z9.boolean() })).max(500),
-  folders: z9.array(z9.object({ project: z9.string(), cwd: z9.string() })).max(100)
+import { z as z10 } from "zod";
+var MachineInventorySchema = z10.object({
+  id: z10.string().min(1).max(80),
+  label: z10.string().min(1).max(120),
+  online: z10.boolean(),
+  local: z10.boolean(),
+  sessions: z10.array(z10.object({ id: z10.string(), name: z10.string(), project: z10.string(), cwd: z10.string(), topic: z10.string().optional(), state: z10.string(), readOnly: z10.boolean() })).max(500),
+  folders: z10.array(z10.object({ project: z10.string(), cwd: z10.string() })).max(100)
 });
-var RoutingContextSchema = z9.object({
-  machines: z9.array(MachineInventorySchema).min(1).max(20),
-  history: z9.array(z9.object({ question: z9.string().max(2e4), answer: z9.string().max(2e4).optional(), machineId: z9.string().optional() })).max(50)
+var RoutingContextSchema = z10.object({
+  machines: z10.array(MachineInventorySchema).min(1).max(20),
+  history: z10.array(z10.object({ question: z10.string().max(2e4), answer: z10.string().max(2e4).optional(), machineId: z10.string().optional() })).max(50)
 });
-var RouteResultSchema = z9.object({
+var RouteResultSchema = z10.object({
   /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z9.string().nullable(),
-  text: z9.string().min(1).max(2e4),
-  choices: z9.array(z9.string()).max(20).optional()
+  machineId: z10.string().nullable(),
+  text: z10.string().min(1).max(2e4),
+  choices: z10.array(z10.string()).max(20).optional()
 });
 
 // ../protocol/src/ssh.ts
-import { z as z10 } from "zod";
-var SshAliasSchema = z10.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
+import { z as z11 } from "zod";
+var SshAliasSchema = z11.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
 
 // ../protocol/src/machines.ts
-import { z as z11 } from "zod";
-var MachineIdSchema = z11.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
-var MachineSchema = z11.object({
+import { z as z12 } from "zod";
+var MachineIdSchema = z12.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var MachineSchema = z12.object({
   id: MachineIdSchema,
-  label: z11.string().trim().min(1).max(80),
+  label: z12.string().trim().min(1).max(80),
   ssh: SshAliasSchema.optional()
 });
-var MachinesSchema = z11.array(MachineSchema).min(1).max(20).superRefine((list, ctx) => {
+var MachinesSchema = z12.array(MachineSchema).min(1).max(20).superRefine((list, ctx) => {
   if (list[0]?.id !== "local" || list[0].ssh !== void 0) ctx.addIssue({ code: "custom", message: "the first machine is local, without ssh", path: [0] });
   const ids = /* @__PURE__ */ new Set(), aliases = /* @__PURE__ */ new Set();
   list.forEach((m, i) => {
@@ -438,53 +490,53 @@ var MachinesSchema = z11.array(MachineSchema).min(1).max(20).superRefine((list,
 });
 
 // ../protocol/src/island.ts
-import { z as z12 } from "zod";
-var IslandScaleSchema = z12.union([z12.literal("auto"), z12.literal(1), z12.literal(1.25), z12.literal(1.5), z12.literal(2)]);
-var IslandPrefsSchema = z12.object({
+import { z as z13 } from "zod";
+var IslandScaleSchema = z13.union([z13.literal("auto"), z13.literal(1), z13.literal(1.25), z13.literal(1.5), z13.literal(2)]);
+var IslandPrefsSchema = z13.object({
   /** Shown at the top of the screen; hidden, Desktop still notifies. */
-  visible: z12.boolean(),
+  visible: z13.boolean(),
   /** `primary` (whichever it is after a reconfiguration), or a monitor's id as the shell lists it (`list_monitors`: the OS
    *  name, `#index` without one). `second`, written by older fronts, is the first monitor that is not the primary. */
-  screen: z12.string().trim().min(1).max(200),
-  position: z12.enum(["center", "left", "right"]),
+  screen: z13.string().trim().min(1).max(200),
+  position: z13.enum(["center", "left", "right"]),
   /** A strip under a maximised window. */
-  discreet: z12.boolean(),
+  discreet: z13.boolean(),
   islandScale: IslandScaleSchema,
   panelScale: IslandScaleSchema,
   /** What the island shows besides asks and questions, which it always shows. */
-  shows: z12.object({
+  shows: z13.object({
     /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
-    quick: z12.boolean(),
+    quick: z13.boolean(),
     /** The 6 s bubble when an agent finishes. */
-    finished: z12.boolean(),
+    finished: z13.boolean(),
     /** An agent's sentence in a bubble. */
-    say: z12.boolean(),
+    say: z13.boolean(),
     /** The sub-agents next to their main agent. */
-    helpers: z12.boolean()
+    helpers: z13.boolean()
   }),
   /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
-  shortcut: z12.string().trim().min(1).max(40)
+  shortcut: z13.string().trim().min(1).max(40)
 });
 
 // ../protocol/src/projects.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var PROJECT_COLORS = { blue: "#3b82f6", green: "#10b981", amber: "#f59e0b", violet: "#8b5cf6", teal: "#14b8a6", pink: "#ec4899", red: "#ef4444", slate: "#64748b" };
-var ProjectColorSchema = z13.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
-var ProjectIdSchema = z13.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+var ProjectColorSchema = z14.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
+var ProjectIdSchema = z14.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
 function normalizePath(raw) {
   const p = raw.trim().replace(/\/+/g, "/");
   return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
 }
-var PathSchema = z13.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
-var RepoSchema = z13.object({ machine: MachineIdSchema, path: PathSchema });
-var ProjectSchema = z13.object({
+var PathSchema = z14.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
+var RepoSchema = z14.object({ machine: MachineIdSchema, path: PathSchema });
+var ProjectSchema = z14.object({
   id: ProjectIdSchema,
-  name: z13.string().trim().min(1).max(80),
+  name: z14.string().trim().min(1).max(80),
   color: ProjectColorSchema,
-  description: z13.string().max(500).default(""),
-  repos: z13.array(RepoSchema).max(50)
+  description: z14.string().max(500).default(""),
+  repos: z14.array(RepoSchema).max(50)
 });
-var RuleSchema = z13.object({ machine: MachineIdSchema, path: PathSchema, project: ProjectIdSchema });
+var RuleSchema = z14.object({ machine: MachineIdSchema, path: PathSchema, project: ProjectIdSchema });
 function projectsProblems(p) {
   const out = [];
   const ids = /* @__PURE__ */ new Set(), names = /* @__PURE__ */ new Set(), repos = /* @__PURE__ */ new Set(), rules = /* @__PURE__ */ new Set();
@@ -510,7 +562,7 @@ ${rule.path}`;
   });
   return out;
 }
-var ProjectsSchema = z13.object({ projects: z13.array(ProjectSchema).max(100), rules: z13.array(RuleSchema).max(1e3) }).superRefine((p, ctx) => {
+var ProjectsSchema = z14.object({ projects: z14.array(ProjectSchema).max(100), rules: z14.array(RuleSchema).max(1e3) }).superRefine((p, ctx) => {
   for (const problem of projectsProblems(p)) ctx.addIssue({ code: "custom", message: problem.code, path: problem.path });
 });
 var DEFAULT_PROJECTS = { projects: [], rules: [] };
@@ -528,51 +580,54 @@ function projectOf(session, state) {
 }
 
 // ../protocol/src/thread.ts
-import { z as z14 } from "zod";
-var ToolStatusSchema = z14.enum(["running", "success", "failed", "unknown"]);
-var FileChangeSchema = z14.object({ path: z14.string().min(1), from: z14.string().min(1).optional(), change: z14.enum(["add", "edit", "delete", "write"]), diff: z14.string().optional() });
-var base = { id: z14.string().min(1), at: z14.string().datetime(), turn: z14.number().int().nonnegative(), helperId: z14.string().optional() };
-var ThreadItemSchema = z14.discriminatedUnion("kind", [
-  z14.object({ kind: z14.literal("prompt"), ...base, text: z14.string() }),
-  z14.object({ kind: z14.literal("message"), ...base, text: z14.string() }),
+import { z as z15 } from "zod";
+var ToolStatusSchema = z15.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z15.object({ path: z15.string().min(1), from: z15.string().min(1).optional(), change: z15.enum(["add", "edit", "delete", "write"]), diff: z15.string().optional() });
+var base = { id: z15.string().min(1), at: z15.string().datetime(), turn: z15.number().int().nonnegative(), helperId: z15.string().optional() };
+var ThreadItemSchema = z15.discriminatedUnion("kind", [
+  z15.object({ kind: z15.literal("prompt"), ...base, text: z15.string(), images: z15.array(AttachmentRefSchema).optional() }),
+  z15.object({ kind: z15.literal("message"), ...base, text: z15.string() }),
   /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row; `byClose`: a question
    *  dismissed by Ledge closing the session. */
-  z14.object({ kind: z14.literal("tool"), ...base, tool: z14.string(), label: z14.string(), input: z14.string().optional(), output: z14.string().optional(), error: z14.string().optional(), status: ToolStatusSchema, durationMs: z14.number().nonnegative().optional(), files: z14.array(FileChangeSchema).default([]), byClose: z14.literal(true).optional() }),
+  z15.object({ kind: z15.literal("tool"), ...base, tool: z15.string(), label: z15.string(), input: z15.string().optional(), output: z15.string().optional(), error: z15.string().optional(), status: ToolStatusSchema, durationMs: z15.number().nonnegative().optional(), files: z15.array(FileChangeSchema).default([]), byClose: z15.literal(true).optional() }),
   /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again;
    *  `byClose`: denied by Ledge closing the session. */
-  z14.object({ kind: z14.literal("permission"), ...base, tool: z14.string(), text: z14.string(), decision: z14.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z14.literal(true).optional() }),
-  z14.object({ kind: z14.literal("reply"), ...base, text: z14.string() }),
-  z14.object({ kind: z14.literal("helper"), ...base, task: z14.string(), agentType: z14.string().optional(), state: z14.enum(["working", "exited"]) }),
+  z15.object({ kind: z15.literal("permission"), ...base, tool: z15.string(), text: z15.string(), decision: z15.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z15.literal(true).optional() }),
+  z15.object({ kind: z15.literal("reply"), ...base, text: z15.string() }),
+  z15.object({ kind: z15.literal("helper"), ...base, task: z15.string(), agentType: z15.string().optional(), state: z15.enum(["working", "exited"]) }),
   /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread, `via` set when Ledge's mailbox carries it. */
-  z14.object({ kind: z14.literal("sent"), ...base, to: z14.string(), peer: z14.string().optional(), summary: z14.string().optional(), text: z14.string(), status: z14.enum(["sending", "delivered", "read", "failed"]), received: z14.string().optional(), via: z14.literal("ledge").optional() }),
+  z15.object({ kind: z15.literal("sent"), ...base, to: z15.string(), peer: z15.string().optional(), summary: z15.string().optional(), text: z15.string(), status: z15.enum(["sending", "delivered", "read", "failed"]), received: z15.string().optional(), via: z15.literal("ledge").optional() }),
   /** A message another agent sent to this session; `from` is its from-name (else its address), `sent` the paired item's id in the peer's thread. */
-  z14.object({ kind: z14.literal("received"), ...base, from: z14.string(), peer: z14.string().optional(), text: z14.string(), sent: z14.string().optional() }),
+  z15.object({ kind: z15.literal("received"), ...base, from: z15.string(), peer: z15.string().optional(), text: z15.string(), sent: z15.string().optional() }),
   /** An automated notice of the agent's harness about messages between sessions (Claude Code's `[Cross-session idle
    *  notice]` / `[Cross-session delivery notice]`): a system event, never the user's words. `name` is the session it is
    *  about as quoted, `peer` its Ledge session id; a delivery notice says the outcome of `count` messages to `recipients`. */
-  z14.object({
-    kind: z14.literal("notice"),
+  z15.object({
+    kind: z15.literal("notice"),
     ...base,
-    notice: z14.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
+    notice: z15.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
     /** An `other` notice from Ledge: `task`, the task a `<ledge-task>` is about; `team`, the team a `<ledge-notice team>` seated the
      *  session in (roles spec §3.3). An older front, which knows neither, shows it as any other notice. */
-    task: z14.string().optional(),
-    team: z14.string().optional(),
-    name: z14.string().optional(),
-    peer: z14.string().optional(),
-    time: z14.string().optional(),
-    summary: z14.string().optional(),
-    status: z14.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
-    count: z14.number().int().positive().optional(),
-    recipients: z14.array(z14.string()).optional(),
-    reason: z14.string().optional(),
-    text: z14.string()
+    task: z15.string().optional(),
+    team: z15.string().optional(),
+    /** A task this session handed over (`outgoing`), and how (issue #92). */
+    taskOp: z15.enum(TRANSMISSION_OPS).optional(),
+    outgoing: z15.literal(true).optional(),
+    name: z15.string().optional(),
+    peer: z15.string().optional(),
+    time: z15.string().optional(),
+    summary: z15.string().optional(),
+    status: z15.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
+    count: z15.number().int().positive().optional(),
+    recipients: z15.array(z15.string()).optional(),
+    reason: z15.string().optional(),
+    text: z15.string()
   })
 ]);
 
 // ../protocol/src/decisions.ts
-import { z as z15 } from "zod";
-var DecisionSchema = z15.enum(["accept", "deny", "always"]);
+import { z as z16 } from "zod";
+var DecisionSchema = z16.enum(["accept", "deny", "always"]);
 var NOTE_MAX = 4e3;
 var NOTE_NOT_TYPED = "note_not_typed";
 var DECISION_OFFERS = {
@@ -602,12 +657,12 @@ function pendingKey(p) {
 }
 
 // ../protocol/src/mobile.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var DEFAULT_RELAY_URL = "https://app.kl-ledge.dev";
-var RelayUrlSchema = z16.string().transform((v, ctx) => {
+var RelayUrlSchema = z17.string().transform((v, ctx) => {
   const bad = () => {
-    ctx.addIssue({ code: z16.ZodIssueCode.custom, message: "invalid relay URL" });
-    return z16.NEVER;
+    ctx.addIssue({ code: z17.ZodIssueCode.custom, message: "invalid relay URL" });
+    return z17.NEVER;
   };
   let u;
   try {
@@ -620,236 +675,248 @@ var RelayUrlSchema = z16.string().transform((v, ctx) => {
   if (u.username || u.password || u.pathname !== "/" || u.search || u.hash) return bad();
   return u.origin;
 });
-var MobileConfigSchema = z16.object({ enabled: z16.boolean(), relayUrl: RelayUrlSchema });
-var MobileLinkStateSchema = z16.discriminatedUnion("state", [
-  z16.object({ state: z16.literal("off") }),
-  z16.object({ state: z16.literal("connecting") }),
-  z16.object({ state: z16.literal("online") }),
-  z16.object({ state: z16.literal("offline"), retryAt: z16.string().datetime(), error: z16.string() }),
-  z16.object({ state: z16.literal("signed_out"), reason: z16.enum(["other_pc", "session_invalid"]) }),
+var MobileConfigSchema = z17.object({ enabled: z17.boolean(), relayUrl: RelayUrlSchema });
+var MobileLinkStateSchema = z17.discriminatedUnion("state", [
+  z17.object({ state: z17.literal("off") }),
+  z17.object({ state: z17.literal("connecting") }),
+  z17.object({ state: z17.literal("online") }),
+  z17.object({ state: z17.literal("offline"), retryAt: z17.string().datetime(), error: z17.string() }),
+  z17.object({ state: z17.literal("signed_out"), reason: z17.enum(["other_pc", "session_invalid"]) }),
   /** The mobile service did not start (a broken mobile.json, a missing key store): nothing is linked until the daemon restarts. */
-  z16.object({ state: z16.literal("unavailable"), error: z16.string().max(200) })
+  z17.object({ state: z17.literal("unavailable"), error: z17.string().max(200) })
 ]);
-var MobilePairingSchema = z16.object({
-  id: z16.string(),
-  label: z16.string(),
-  code: z16.string().nullable(),
-  expiresAt: z16.string().datetime(),
-  state: z16.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
+var MobilePairingSchema = z17.object({
+  id: z17.string(),
+  label: z17.string(),
+  code: z17.string().nullable(),
+  expiresAt: z17.string().datetime(),
+  state: z17.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
 });
-var MobileStateSchema = z16.object({
-  enabled: z16.boolean(),
-  relayUrl: z16.string(),
-  account: z16.object({ login: z16.string(), accountId: z16.string() }).nullable(),
-  signin: z16.object({ userCode: z16.string(), verificationUri: z16.string(), expiresAt: z16.string().datetime() }).nullable(),
+var MobileStateSchema = z17.object({
+  enabled: z17.boolean(),
+  relayUrl: z17.string(),
+  account: z17.object({ login: z17.string(), accountId: z17.string() }).nullable(),
+  signin: z17.object({ userCode: z17.string(), verificationUri: z17.string(), expiresAt: z17.string().datetime() }).nullable(),
   /** The last sign-in that did not end with a session; cleared by the next one. */
-  signinError: z16.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
+  signinError: z17.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
   link: MobileLinkStateSchema,
-  devices: z16.array(z16.object({ id: z16.string(), label: z16.string(), approvedAt: z16.string(), online: z16.boolean(), lastSeenAt: z16.string().optional() })),
-  pairings: z16.array(MobilePairingSchema)
+  devices: z17.array(z17.object({ id: z17.string(), label: z17.string(), approvedAt: z17.string(), online: z17.boolean(), lastSeenAt: z17.string().optional() })),
+  pairings: z17.array(MobilePairingSchema)
 });
 
 // ../protocol/src/teams.ts
-import { z as z17 } from "zod";
-var RoleIdSchema = z17.string().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/);
+import { z as z18 } from "zod";
+var RoleIdSchema = z18.string().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/);
 var ROLE_LABEL_MAX = 40;
 var ROLE_PROMPT_MAX = 8e3;
-var RoleSchema = z17.object({
+var RoleSchema = z18.object({
   id: RoleIdSchema,
-  label: z17.string().min(1).max(ROLE_LABEL_MAX),
-  prompt: z17.string().max(ROLE_PROMPT_MAX),
+  label: z18.string().min(1).max(ROLE_LABEL_MAX),
+  prompt: z18.string().max(ROLE_PROMPT_MAX),
   tool: ToolSchema.optional(),
   model: ModelIdSchema.optional(),
   effort: EffortSchema.optional(),
   autonomy: AutonomySchema.optional(),
-  source: z17.enum(["repo", "home"]),
-  path: z17.string()
+  source: z18.enum(["repo", "home"]),
+  path: z18.string()
 });
-var DefinitionProblemSchema = z17.object({ path: z17.string(), reason: z17.string() });
+var DefinitionProblemSchema = z18.object({ path: z18.string(), reason: z18.string() });
 var TEAM_SEATS_MAX = 8;
-var SeatSchema = z17.object({
+var SeatSchema = z18.object({
   role: RoleIdSchema,
   tool: ToolSchema.optional(),
   model: ModelIdSchema.optional(),
   effort: EffortSchema.optional(),
-  name: z17.string().min(1).max(40).optional()
+  name: z18.string().min(1).max(40).optional()
 });
 var uniqueRoles = (seats) => new Set(seats.map((s) => s.role)).size === seats.length;
-var SeatsSchema = z17.array(SeatSchema).min(1).max(TEAM_SEATS_MAX).refine(uniqueRoles, "a role twice in one team");
-var TeamNameSchema = z17.string().trim().min(1).max(60);
-var TeamTemplateSchema = z17.object({ id: z17.string().min(1).max(64), name: TeamNameSchema, seats: SeatsSchema, source: z17.enum(["repo", "home"]), path: z17.string() });
-var TeamIdSchema = z17.string().regex(/^team-[0-9a-f]{4,8}$/);
-var TeamStateSchema = z17.enum(["active", "resting", "dissolved"]);
-var TeamSchema = z17.object({
+var SeatsSchema = z18.array(SeatSchema).min(1).max(TEAM_SEATS_MAX).refine(uniqueRoles, "a role twice in one team");
+var TeamNameSchema = z18.string().trim().min(1).max(60);
+var TeamTemplateSchema = z18.object({ id: z18.string().min(1).max(64), name: TeamNameSchema, seats: SeatsSchema, source: z18.enum(["repo", "home"]), path: z18.string() });
+var TeamIdSchema = z18.string().regex(/^team-[0-9a-f]{4,8}$/);
+var TeamStateSchema = z18.enum(["active", "resting", "dissolved"]);
+var TeamSchema = z18.object({
   id: TeamIdSchema,
   name: TeamNameSchema,
-  template: z17.string().optional(),
-  project: z17.string().nullable(),
-  machine: z17.string(),
-  cwd: z17.string(),
+  template: z18.string().optional(),
+  project: z18.string().nullable(),
+  machine: z18.string(),
+  cwd: z18.string(),
   state: TeamStateSchema,
-  seats: z17.array(z17.object({ role: RoleIdSchema, sessionId: z17.string().nullable() })).max(TEAM_SEATS_MAX * 2),
-  createdAt: z17.string(),
-  updatedAt: z17.string(),
-  restingAt: z17.string().optional(),
-  dissolvedAt: z17.string().optional()
+  seats: z18.array(z18.object({ role: RoleIdSchema, sessionId: z18.string().nullable() })).max(TEAM_SEATS_MAX * 2),
+  createdAt: z18.string(),
+  updatedAt: z18.string(),
+  restingAt: z18.string().optional(),
+  dissolvedAt: z18.string().optional()
 });
-var RolesListSchema = z17.object({ type: z17.literal("roles.list"), cwd: z17.string().min(1).optional(), requestId: z17.string().max(100).optional(), machineId: z17.string().optional() });
-var RolesListingSchema = z17.object({ type: z17.literal("roles.listing"), requestId: z17.string().optional(), roles: z17.array(RoleSchema), templates: z17.array(TeamTemplateSchema).default([]), problems: z17.array(DefinitionProblemSchema) });
-var TeamLaunchSchema = z17.object({
-  type: z17.literal("team.launch"),
-  rid: z17.string().min(1).max(100),
-  cwd: z17.string().min(1).optional(),
-  template: z17.string().min(1).max(64).optional(),
+var RolesListSchema = z18.object({ type: z18.literal("roles.list"), cwd: z18.string().min(1).optional(), requestId: z18.string().max(100).optional(), machineId: z18.string().optional() });
+var RolesListingSchema = z18.object({ type: z18.literal("roles.listing"), requestId: z18.string().optional(), roles: z18.array(RoleSchema), templates: z18.array(TeamTemplateSchema).default([]), problems: z18.array(DefinitionProblemSchema) });
+var TeamLaunchSchema = z18.object({
+  type: z18.literal("team.launch"),
+  rid: z18.string().min(1).max(100),
+  cwd: z18.string().min(1).optional(),
+  template: z18.string().min(1).max(64).optional(),
   seats: SeatsSchema.optional(),
   name: TeamNameSchema.optional(),
-  qid: z17.string().min(1).optional(),
-  machineId: z17.string().optional()
+  qid: z18.string().min(1).optional(),
+  machineId: z18.string().optional()
 });
-var TeamJoinSchema = z17.object({ type: z17.literal("team.join"), team: TeamIdSchema, session: z17.string().min(1), role: RoleIdSchema });
-var TeamLeaveSchema = z17.object({ type: z17.literal("team.leave"), team: TeamIdSchema, session: z17.string().min(1) });
-var TeamResumeSchema = z17.object({ type: z17.literal("team.resume"), team: TeamIdSchema });
-var TeamDissolveSchema = z17.object({ type: z17.literal("team.dissolve"), team: TeamIdSchema });
-var TeamSaveSchema = z17.object({ type: z17.literal("team.save"), rid: z17.string().min(1).max(100), name: TeamNameSchema, seats: SeatsSchema, qid: z17.string().min(1).optional() });
-var TeamsMessageSchema = z17.object({ type: z17.literal("teams"), teams: z17.array(TeamSchema) });
-var TeamUpdatedSchema = z17.object({ type: z17.literal("team.updated"), team: TeamSchema });
-var TeamLaunchedSchema = z17.object({ type: z17.literal("team.launched"), rid: z17.string(), team: TeamSchema });
-var TeamFailedSchema = z17.object({ type: z17.literal("team.failed"), rid: z17.string(), reason: z17.string(), team: TeamSchema.optional() });
-var TeamSavedSchema = z17.object({ type: z17.literal("team.saved"), rid: z17.string(), path: z17.string().optional(), reason: z17.string().optional() });
+var TeamJoinSchema = z18.object({ type: z18.literal("team.join"), team: TeamIdSchema, session: z18.string().min(1), role: RoleIdSchema });
+var TeamLeaveSchema = z18.object({ type: z18.literal("team.leave"), team: TeamIdSchema, session: z18.string().min(1) });
+var TeamResumeSchema = z18.object({ type: z18.literal("team.resume"), team: TeamIdSchema });
+var TeamDissolveSchema = z18.object({ type: z18.literal("team.dissolve"), team: TeamIdSchema });
+var TeamSaveSchema = z18.object({ type: z18.literal("team.save"), rid: z18.string().min(1).max(100), name: TeamNameSchema, seats: SeatsSchema, qid: z18.string().min(1).optional() });
+var TeamsMessageSchema = z18.object({ type: z18.literal("teams"), teams: z18.array(TeamSchema) });
+var TeamUpdatedSchema = z18.object({ type: z18.literal("team.updated"), team: TeamSchema });
+var TeamLaunchedSchema = z18.object({ type: z18.literal("team.launched"), rid: z18.string(), team: TeamSchema });
+var TeamFailedSchema = z18.object({ type: z18.literal("team.failed"), rid: z18.string(), reason: z18.string(), team: TeamSchema.optional() });
+var TeamSavedSchema = z18.object({ type: z18.literal("team.saved"), rid: z18.string(), path: z18.string().optional(), reason: z18.string().optional() });
 
 // ../protocol/src/messages.ts
 var PROTOCOL_PORT = 47831;
-var RefusalCodeSchema = z18.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid"]);
-var SessionEventSchema = z18.object({
-  name: z18.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
-  at: z18.string().datetime(),
-  source: z18.enum(["hook", "pane", "daemon"]),
-  tool: z18.string().optional(),
-  text: z18.string().optional(),
-  options: z18.array(z18.string()).optional(),
+var RefusalCodeSchema = z19.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid", "attachment_missing", "attachments_not_accepted"]);
+var SessionEventSchema = z19.object({
+  name: z19.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
+  at: z19.string().datetime(),
+  source: z19.enum(["hook", "pane", "daemon"]),
+  tool: z19.string().optional(),
+  text: z19.string().optional(),
+  options: z19.array(z19.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z18.array(z18.string()).optional(),
-  kind: z18.enum(["question", "permission", "plan", "diff"]).optional(),
+  optionDetails: z19.array(z19.string()).optional(),
+  kind: z19.enum(["question", "permission", "plan", "diff"]).optional(),
   /** PanePrompt: what to review in full before deciding (a plan read in the terminal), when `text` is its summary. */
-  body: z18.string().optional(),
-  exitCode: z18.number().int().nullable().optional(),
-  helperId: z18.string().optional(),
+  body: z19.string().optional(),
+  exitCode: z19.number().int().nullable().optional(),
+  helperId: z19.string().optional(),
   /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z18.string().optional(),
+  task: z19.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z18.boolean().optional(),
+  interrupt: z19.boolean().optional(),
+  /** UserPromptSubmit: the images the prompt carried, by attachment id. */
+  attachments: z19.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
   /** QueueUpdate: OMP's queue as it stands. */
-  queue: z18.array(z18.object({ text: z18.string(), mode: z18.enum(["steer", "follow_up"]) })).optional(),
+  queue: z19.array(z19.object({ text: z19.string(), mode: z19.enum(["steer", "follow_up"]) })).optional(),
   /** AgentMessage: the harness's own message, its text so far (`streaming`) or whole. `messageId` is unique for the session's life. */
-  messageId: z18.string().optional(),
-  streaming: z18.boolean().optional(),
+  messageId: z19.string().optional(),
+  streaming: z19.boolean().optional(),
   /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
-  requestId: z18.string().optional(),
-  questions: z18.array(AskQuestionSchema).optional(),
+  requestId: z19.string().optional(),
+  questions: z19.array(AskQuestionSchema).optional(),
   /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
-  streamed: z18.boolean().optional(),
+  streamed: z19.boolean().optional(),
   /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
-  toolUseId: z18.string().optional(),
+  toolUseId: z19.string().optional(),
   /** The tool's input as the harness gave it, every string capped by the hook. */
-  toolInput: z18.record(z18.string(), z18.unknown()).optional(),
+  toolInput: z19.record(z19.string(), z19.unknown()).optional(),
   /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z18.string().optional(),
-  durationMs: z18.number().nonnegative().optional(),
+  output: z19.string().optional(),
+  durationMs: z19.number().nonnegative().optional(),
   /** PostToolUseFailure: the harness's error message. */
-  error: z18.string().optional(),
+  error: z19.string().optional(),
   /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
-  transcriptPath: z18.string().optional(),
+  transcriptPath: z19.string().optional(),
   /** Decided: what was chosen when the daemon knows it. */
   decision: DecisionSchema.optional(),
   /** Decided: the request was refused by Ledge closing the session (its interrupt keys), not by the user's answer. */
-  byClose: z18.literal(true).optional(),
+  byClose: z19.literal(true).optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
-  agentSessionId: z18.string().optional()
+  agentSessionId: z19.string().optional()
 });
-var RecentSchema = z18.object({ cwd: z18.string().min(1), project: z18.string().min(1), lastAt: z18.string().datetime() });
+var RecentSchema = z19.object({ cwd: z19.string().min(1), project: z19.string().min(1), lastAt: z19.string().datetime() });
 var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z18.object({
-  version: z18.string(),
-  install: z18.enum(["npm", "git", "unknown"]),
-  systemd: z18.boolean(),
-  manual: z18.string().optional(),
-  routing: z18.boolean().optional(),
-  archive: z18.boolean().optional(),
+var DaemonInfoSchema = z19.object({
+  version: z19.string(),
+  install: z19.enum(["npm", "git", "unknown"]),
+  systemd: z19.boolean(),
+  manual: z19.string().optional(),
+  routing: z19.boolean().optional(),
+  archive: z19.boolean().optional(),
   /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
-  models: z18.boolean().optional(),
+  models: z19.boolean().optional(),
   /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
-  omp: z18.boolean().optional(),
+  omp: z19.boolean().optional(),
   /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
-  modelSwitch: z18.boolean().optional(),
+  modelSwitch: z19.boolean().optional(),
   /** Takes `approval` on an OMP `session.launch` (auto mode). */
-  ompApproval: z18.boolean().optional(),
+  ompApproval: z19.boolean().optional(),
   /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
-  home: z18.string().optional(),
-  mobile: z18.boolean().optional(),
+  home: z19.string().optional(),
+  mobile: z19.boolean().optional(),
   /** Knows roles, teams and tasks given by Ledge (spec 2026-10-25 roles). */
-  teams: z18.boolean().optional()
+  teams: z19.boolean().optional()
 });
-var UpdateFailureSchema = z18.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z18.discriminatedUnion("type", [
-  z18.object({ type: z18.literal("chat.routed"), qid: z18.string(), result: RouteResultSchema }),
+var UpdateFailureSchema = z19.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z19.discriminatedUnion("type", [
+  z19.object({ type: z19.literal("chat.routed"), qid: z19.string(), result: RouteResultSchema }),
   DocumentContentSchema,
   DocumentErrorSchema,
+  AttachmentStoredSchema,
+  AttachmentDataSchema,
+  AttachmentErrorSchema,
   ReposInfoSchema,
   ReposFoundSchema,
   ModelsListingSchema,
   /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
    *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
    *  from daemons older than the auto-update. */
-  z18.object({ type: z18.literal("snapshot"), sessions: z18.array(SessionSchema), recents: z18.array(RecentSchema).optional(), launcher: z18.array(z18.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
-  z18.object({ type: z18.literal("session.updated"), session: SessionSchema }),
+  z19.object({ type: z19.literal("snapshot"), sessions: z19.array(SessionSchema), recents: z19.array(RecentSchema).optional(), launcher: z19.array(z19.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z19.object({ type: z19.literal("session.updated"), session: SessionSchema }),
   /** OMP: the instructions taken back from its queue by an interrupt that restores it; the asker puts them back in its draft. */
-  z18.object({ type: z18.literal("session.queue.restored"), id: z18.string(), texts: z18.array(z18.string()) }),
-  z18.object({ type: z18.literal("session.removed"), id: z18.string() }),
-  z18.object({ type: z18.literal("session.preview"), id: z18.string(), lines: z18.array(z18.string()) }),
+  z19.object({
+    type: z19.literal("session.queue.restored"),
+    id: z19.string(),
+    texts: z19.array(z19.string()),
+    /** The same instructions with the images they carried; `imagesDropped`: some images could not be put back. */
+    entries: z19.array(z19.object({ text: z19.string(), attachments: z19.array(AttachmentIdSchema).optional() })).optional(),
+    imagesDropped: z19.boolean().optional()
+  }),
+  z19.object({ type: z19.literal("session.removed"), id: z19.string() }),
+  z19.object({ type: z19.literal("session.preview"), id: z19.string(), lines: z19.array(z19.string()) }),
   /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
-  z18.object({ type: z18.literal("session.thread"), id: z18.string(), items: z18.array(ThreadItemSchema) }),
-  z18.object({ type: z18.literal("session.thread.item"), id: z18.string(), item: ThreadItemSchema }),
+  z19.object({ type: z19.literal("session.thread"), id: z19.string(), items: z19.array(ThreadItemSchema) }),
+  z19.object({ type: z19.literal("session.thread.item"), id: z19.string(), item: ThreadItemSchema }),
   /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
-  z18.object({ type: z18.literal("session.launched"), id: z18.string() }),
+  z19.object({ type: z19.literal("session.launched"), id: z19.string() }),
   /** Answer to the requester of a `session.close`, once per row closed: the session `id` and how it ended. */
-  z18.object({ type: z18.literal("session.closed"), qid: z18.string(), row: z18.number().int().min(0), id: z18.string(), how: z18.enum(["exit", "killed"]) }),
-  z18.object({ type: z18.literal("recents"), recents: z18.array(RecentSchema) }),
+  z19.object({ type: z19.literal("session.closed"), qid: z19.string(), row: z19.number().int().min(0), id: z19.string(), how: z19.enum(["exit", "killed"]) }),
+  z19.object({ type: z19.literal("recents"), recents: z19.array(RecentSchema) }),
   /** Answer to the requester of a `folder.list` or `folder.create`: `path` resolved (`~` expanded), `parent` null at the
    *  root, `entries` its subfolders by name (hidden ones left out). A failure keeps the asked path and says why in `error`,
    *  never in an `error` message, which the launch form reads as a failed launch. */
-  z18.object({
-    type: z18.literal("folder.listing"),
-    path: z18.string(),
-    parent: z18.string().nullable(),
-    entries: z18.array(z18.string()),
-    error: z18.string().optional(),
+  z19.object({
+    type: z19.literal("folder.listing"),
+    path: z19.string(),
+    parent: z19.string().nullable(),
+    entries: z19.array(z19.string()),
+    error: z19.string().optional(),
     /** The request this answers, when it carried one. */
-    requestId: z18.string().optional(),
+    requestId: z19.string().optional(),
     /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
-    repos: z18.array(z18.object({ name: z18.string(), branch: z18.string() })).optional()
+    repos: z19.array(z19.object({ name: z19.string(), branch: z19.string() })).optional()
   }),
   /** The chat (spec 2026-10-11 §5): what Ledge reads, its words as they come, the final text, or why it stopped; the day's turns after each snapshot. */
-  z18.object({ type: z18.literal("chat.step"), qid: z18.string(), step: ChatStepSchema }),
-  z18.object({ type: z18.literal("chat.delta"), qid: z18.string(), text: z18.string() }),
-  z18.object({ type: z18.literal("chat.done"), qid: z18.string(), text: z18.string(), at: z18.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), team: ChatTeamProposalSchema.optional(), tasks: ChatTasksSchema.optional() }),
-  z18.object({ type: z18.literal("chat.error"), qid: z18.string(), message: z18.string() }),
-  z18.object({ type: z18.literal("chat.history"), turns: z18.array(ChatTurnSchema) }),
+  z19.object({ type: z19.literal("chat.step"), qid: z19.string(), step: ChatStepSchema }),
+  z19.object({ type: z19.literal("chat.delta"), qid: z19.string(), text: z19.string() }),
+  z19.object({ type: z19.literal("chat.done"), qid: z19.string(), text: z19.string(), at: z19.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), team: ChatTeamProposalSchema.optional(), tasks: ChatTasksSchema.optional() }),
+  z19.object({ type: z19.literal("chat.error"), qid: z19.string(), message: z19.string() }),
+  z19.object({ type: z19.literal("chat.history"), turns: z19.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
-  z18.object({ type: z18.literal("update.progress"), version: z18.string(), step: z18.enum(["installing", "restarting"]) }),
+  z19.object({ type: z19.literal("update.progress"), version: z19.string(), step: z19.enum(["installing", "restarting"]) }),
   /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
-  z18.object({ type: z18.literal("update.failed"), version: z18.string(), reason: UpdateFailureSchema, detail: z18.string().optional(), command: z18.string().optional() }),
+  z19.object({ type: z19.literal("update.failed"), version: z19.string(), reason: UpdateFailureSchema, detail: z19.string().optional(), command: z19.string().optional() }),
   /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z18.object({ type: z18.literal("machines"), machines: MachinesSchema }),
+  z19.object({ type: z19.literal("machines"), machines: MachinesSchema }),
   /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
-  z18.object({ type: z18.literal("projects"), projects: ProjectsSchema }),
+  z19.object({ type: z19.literal("projects"), projects: ProjectsSchema }),
   /** The island's settings shared by the local fronts; null until a front sets them (the island then sends its own). Local clients only. */
-  z18.object({ type: z18.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  z19.object({ type: z19.literal("island"), prefs: IslandPrefsSchema.nullable() }),
   /** Mobile access (lot 3), after the island in each snapshot and on every change. Local clients only. */
-  z18.object({ type: z18.literal("mobile"), state: MobileStateSchema }),
+  z19.object({ type: z19.literal("mobile"), state: MobileStateSchema }),
   /** The daemon's immediate answer to a `session.message`: delivered (`accepted`), held for later (`queued`), left to Claude's own SendMessage (`native`), or refused with a `reason`. */
-  z18.object({ type: z18.literal("message.ack"), rid: z18.string(), outcome: z18.enum(["accepted", "queued", "native", "refused"]), reason: z18.string().optional() }),
+  z19.object({ type: z19.literal("message.ack"), rid: z19.string(), outcome: z19.enum(["accepted", "queued", "native", "refused"]), reason: z19.string().optional() }),
   /** The answer to a `message.read`: the body with its sender, target and time, or the refusal's `reason`. */
-  z18.object({ type: z18.literal("message.body"), id: z18.string(), from: z18.string().optional(), to: z18.string().optional(), at: z18.string().optional(), text: z18.string().optional(), reason: z18.string().optional() }),
+  z19.object({ type: z19.literal("message.body"), id: z19.string(), from: z19.string().optional(), to: z19.string().optional(), at: z19.string().optional(), text: z19.string().optional(), reason: z19.string().optional() }),
   TaskResultSchema,
   SessionHandoverResultSchema,
   ContextPrefsMessageSchema,
@@ -861,22 +928,24 @@ var ServerMessageSchema = z18.discriminatedUnion("type", [
   TeamLaunchedSchema,
   TeamFailedSchema,
   TeamSavedSchema,
-  z18.object({
-    type: z18.literal("error"),
-    message: z18.string(),
-    id: z18.string().optional(),
+  z19.object({
+    type: z19.literal("error"),
+    message: z19.string(),
+    id: z19.string().optional(),
     /** Le type du message client refusé. */
-    request: z18.string().optional(),
+    request: z19.string().optional(),
     /** Ce que le front doit reconnaître au-delà du texte (NOTE_NOT_TYPED) ; une chaîne libre, qu'un front plus ancien ignore. */
-    code: z18.string().optional()
+    code: z19.string().optional()
   })
 ]);
 var MESSAGE_MAX = 2e4;
 var SUMMARY_MAX = 500;
-var launchRows = z18.array(z18.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var ClientMessageSchema = z18.discriminatedUnion("type", [
-  z18.object({ type: z18.literal("chat.route"), qid: z18.string().min(1).max(100), text: z18.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+var launchRows = z19.array(z19.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var ClientMessageSchema = z19.discriminatedUnion("type", [
+  z19.object({ type: z19.literal("chat.route"), qid: z19.string().min(1).max(100), text: z19.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
+  AttachmentPutSchema,
+  AttachmentGetSchema,
   ReposInspectSchema,
   ReposScanSchema,
   ModelsListSchema,
@@ -884,18 +953,18 @@ var ClientMessageSchema = z18.discriminatedUnion("type", [
    *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
    *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields
    *  but `rows`, `model` and `effort`. */
-  z18.object({
-    type: z18.literal("session.launch"),
+  z19.object({
+    type: z19.literal("session.launch"),
     tool: ToolSchema,
-    cwd: z18.string().min(1),
-    name: z18.string().optional(),
-    prompt: z18.string().optional(),
-    continue: z18.boolean().optional(),
-    qid: z18.string().min(1).optional(),
+    cwd: z19.string().min(1),
+    name: z19.string().optional(),
+    prompt: z19.string().optional(),
+    continue: z19.boolean().optional(),
+    qid: z19.string().min(1).optional(),
     /** With `qid`: the card's rows to launch (#24), indexes into the turn's `proposals`, each once; the first row without it. */
     rows: launchRows.optional(),
     /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
-    dirs: z18.array(z18.string().min(1)).max(20).optional(),
+    dirs: z19.array(z19.string().min(1)).max(20).optional(),
     /** The agent's model and effort (#58), the agent's own default when left out; with `qid`, for every row launched. */
     model: ModelIdSchema.optional(),
     effort: EffortSchema.optional(),
@@ -906,98 +975,98 @@ var ClientMessageSchema = z18.discriminatedUnion("type", [
     /** A live team the new session joins at once, in `role`. */
     team: TeamIdSchema.optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z18.string().optional()
+    machineId: z19.string().optional()
   }),
   /** The launch form's folder browser: list a folder's subfolders (home when no `path`), or make `name` inside `parent`
    *  and list it. Both are answered with a `folder.listing`. */
-  z18.object({
-    type: z18.literal("folder.list"),
-    path: z18.string().optional(),
+  z19.object({
+    type: z19.literal("folder.list"),
+    path: z19.string().optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z18.string().optional(),
+    machineId: z19.string().optional(),
     /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
-    requestId: z18.string().min(1).max(100).optional()
+    requestId: z19.string().min(1).max(100).optional()
   }),
-  z18.object({
-    type: z18.literal("folder.create"),
-    parent: z18.string().min(1),
-    name: z18.string().min(1),
+  z19.object({
+    type: z19.literal("folder.create"),
+    parent: z19.string().min(1),
+    name: z19.string().min(1),
     /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
-    machineId: z18.string().optional(),
-    requestId: z18.string().min(1).max(100).optional()
+    machineId: z19.string().optional(),
+    requestId: z19.string().min(1).max(100).optional()
   }),
   /** `steer`: OMP only, redirect the turn running now instead of queueing the text after it. */
   /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order (`selected` labels, and/or free `text`); `cancel` declines it. */
-  z18.object({ type: z18.literal("session.answer"), id: z18.string(), requestId: z18.string().min(1).max(200), answers: z18.array(z18.object({ id: z18.string(), selected: z18.array(z18.string().max(2e3)).max(100), text: z18.string().max(2e4).optional() })).max(50), cancel: z18.boolean().optional() }),
-  z18.object({ type: z18.literal("session.reply"), id: z18.string(), text: z18.string().min(1), steer: z18.boolean().optional() }),
+  z19.object({ type: z19.literal("session.answer"), id: z19.string(), requestId: z19.string().min(1).max(200), answers: z19.array(z19.object({ id: z19.string(), selected: z19.array(z19.string().max(2e3)).max(100), text: z19.string().max(2e4).optional() })).max(50), cancel: z19.boolean().optional() }),
+  z19.object({ type: z19.literal("session.reply"), id: z19.string(), text: z19.string(), attachments: z19.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(), steer: z19.boolean().optional() }),
   /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
-  z18.object({ type: z18.literal("session.relay"), qid: z18.string().min(1) }),
+  z19.object({ type: z19.literal("session.relay"), qid: z19.string().min(1) }),
   /** Takes the card's queued instruction back out of the queue. */
-  z18.object({ type: z18.literal("session.relay.cancel"), qid: z18.string().min(1) }),
+  z19.object({ type: z19.literal("session.relay.cancel"), qid: z19.string().min(1) }),
   /** The chat's close card: closes the turn's sessions, `rows` (indexes into its `closes`) or all of them. */
-  z18.object({ type: z18.literal("session.close"), qid: z18.string().min(1), rows: launchRows.optional() }),
+  z19.object({ type: z19.literal("session.close"), qid: z19.string().min(1), rows: launchRows.optional() }),
   /** `always` and `note` only where the harness offers them (`offers`); a note goes with `deny`, for the agent to read. */
-  z18.object({
-    type: z18.literal("session.decide"),
-    id: z18.string(),
+  z19.object({
+    type: z19.literal("session.decide"),
+    id: z19.string(),
     decision: DecisionSchema,
-    note: z18.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z19.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the user saw when deciding: refused (the request changed) unless it is still the pending one. Left out by older fronts and the island.
      *  `key` (pendingKey) covers its whole content; older fronts send kind and text only. */
-    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z18.string().max(64).optional() }).optional()
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z19.string().max(64).optional() }).optional()
   }),
-  z18.object({ type: z18.literal("session.focus"), id: z18.string() }),
-  z18.object({ type: z18.literal("session.kill"), id: z18.string() }),
+  z19.object({ type: z19.literal("session.focus"), id: z19.string() }),
+  z19.object({ type: z19.literal("session.kill"), id: z19.string() }),
   /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
-  z18.object({ type: z18.literal("session.interrupt"), id: z18.string(), restoreQueue: z18.boolean().optional() }),
+  z19.object({ type: z19.literal("session.interrupt"), id: z19.string(), restoreQueue: z19.boolean().optional() }),
   /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
-  z18.object({ type: z18.literal("session.dismiss"), id: z18.string() }),
+  z19.object({ type: z19.literal("session.dismiss"), id: z19.string() }),
   /** Puts a session in the archive: it leaves the live list but is kept. */
-  z18.object({ type: z18.literal("session.archive"), id: z18.string() }),
+  z19.object({ type: z19.literal("session.archive"), id: z19.string() }),
   /** Takes an archived session back out of the archive, as it was. */
-  z18.object({ type: z18.literal("session.restore"), id: z18.string() }),
+  z19.object({ type: z19.literal("session.restore"), id: z19.string() }),
   /** Starts the agent again on an archived session's conversation. */
-  z18.object({ type: z18.literal("session.resume"), id: z18.string() }),
+  z19.object({ type: z19.literal("session.resume"), id: z19.string() }),
   /** Changes a live session's model and effort (#58, lot 2), `null` for the agent's own default: the daemon restarts the
    *  agent on the same conversation with them, at once when the session is free, else at its next free moment. */
-  z18.object({ type: z18.literal("session.model"), id: z18.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  z19.object({ type: z19.literal("session.model"), id: z19.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** Deletes a session for good, archived or not. */
-  z18.object({ type: z18.literal("session.delete"), id: z18.string() }),
+  z19.object({ type: z19.literal("session.delete"), id: z19.string() }),
   /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
-  z18.object({ type: z18.literal("session.rename"), id: z18.string(), topic: z18.string().max(500) }),
-  z18.object({ type: z18.literal("session.thread"), id: z18.string() }),
-  z18.object({ type: z18.literal("session.register"), session: SessionSchema }),
+  z19.object({ type: z19.literal("session.rename"), id: z19.string(), topic: z19.string().max(500) }),
+  z19.object({ type: z19.literal("session.thread"), id: z19.string() }),
+  z19.object({ type: z19.literal("session.register"), session: SessionSchema }),
   /** `agent` and `cwd` describe the session when the daemon does not know it yet (a hook from an agent started without ledge). */
-  z18.object({ type: z18.literal("session.event"), id: z18.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z18.string().optional() }),
-  z18.object({ type: z18.literal("session.unregister"), id: z18.string(), exitCode: z18.number().int().nullable() }),
-  z18.object({ type: z18.literal("snapshot.request") }),
-  z18.object({ type: z18.literal("chat.ask"), qid: z18.string().min(1), text: z18.string().min(1), tool: ToolSchema.optional() }),
-  z18.object({ type: z18.literal("chat.cancel"), qid: z18.string().min(1) }),
+  z19.object({ type: z19.literal("session.event"), id: z19.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z19.string().optional() }),
+  z19.object({ type: z19.literal("session.unregister"), id: z19.string(), exitCode: z19.number().int().nullable() }),
+  z19.object({ type: z19.literal("snapshot.request") }),
+  z19.object({ type: z19.literal("chat.ask"), qid: z19.string().min(1), text: z19.string(), images: z19.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
+  z19.object({ type: z19.literal("chat.cancel"), qid: z19.string().min(1) }),
   /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
-  z18.object({ type: z18.literal("chat.reset") }),
+  z19.object({ type: z19.literal("chat.reset") }),
   /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
-  z18.object({ type: z18.literal("update.daemon"), version: z18.string().regex(SEMVER) }),
+  z19.object({ type: z19.literal("update.daemon"), version: z19.string().regex(SEMVER) }),
   /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
-  z18.object({ type: z18.literal("machines.set"), machines: MachinesSchema }),
+  z19.object({ type: z19.literal("machines.set"), machines: MachinesSchema }),
   /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
-  z18.object({ type: z18.literal("projects.set"), projects: ProjectsSchema }),
+  z19.object({ type: z19.literal("projects.set"), projects: ProjectsSchema }),
   /** Replaces the island's settings as a whole; refused unless valid. */
-  z18.object({ type: z18.literal("island.set"), prefs: IslandPrefsSchema }),
+  z19.object({ type: z19.literal("island.set"), prefs: IslandPrefsSchema }),
   /** Mobile access (lot 3), local fronts only. A changed `relayUrl` drops the relay session. */
-  z18.object({ type: z18.literal("mobile.set"), enabled: z18.boolean(), relayUrl: RelayUrlSchema }),
-  z18.object({ type: z18.literal("mobile.signin") }),
-  z18.object({ type: z18.literal("mobile.signin.cancel") }),
-  z18.object({ type: z18.literal("mobile.signout") }),
+  z19.object({ type: z19.literal("mobile.set"), enabled: z19.boolean(), relayUrl: RelayUrlSchema }),
+  z19.object({ type: z19.literal("mobile.signin") }),
+  z19.object({ type: z19.literal("mobile.signin.cancel") }),
+  z19.object({ type: z19.literal("mobile.signout") }),
   /** While the link is offline: try again now. */
-  z18.object({ type: z18.literal("mobile.retry") }),
-  z18.object({ type: z18.literal("mobile.pairing.approve"), id: z18.string().min(1).max(100) }),
-  z18.object({ type: z18.literal("mobile.pairing.deny"), id: z18.string().min(1).max(100) }),
+  z19.object({ type: z19.literal("mobile.retry") }),
+  z19.object({ type: z19.literal("mobile.pairing.approve"), id: z19.string().min(1).max(100) }),
+  z19.object({ type: z19.literal("mobile.pairing.deny"), id: z19.string().min(1).max(100) }),
   /** `id`: the device's fingerprint. */
-  z18.object({ type: z18.literal("mobile.device.revoke"), id: z18.string().min(1).max(100) }),
+  z19.object({ type: z19.literal("mobile.device.revoke"), id: z19.string().min(1).max(100) }),
   /** One session writing to another by Ledge name (`to` may end in ` [ref]`); `intercept` (the Claude hook): answer `native` unless `to` is a live non-Claude session. */
-  z18.object({ type: z18.literal("session.message"), rid: z18.string().min(1), from: z18.string().min(1), to: z18.string().min(1), text: z18.string().min(1).max(MESSAGE_MAX), summary: z18.string().max(SUMMARY_MAX).optional(), intercept: z18.boolean().optional() }),
+  z19.object({ type: z19.literal("session.message"), rid: z19.string().min(1), from: z19.string().min(1), to: z19.string().min(1), text: z19.string().min(1).max(MESSAGE_MAX), summary: z19.string().max(SUMMARY_MAX).optional(), intercept: z19.boolean().optional() }),
   /** `ledge read <id>`: a message's whole body, for its receiver or its sender (`by`, a session id). */
-  z18.object({ type: z18.literal("message.read"), id: z18.string().min(1).max(40), by: z18.string().min(1) }),
+  z19.object({ type: z19.literal("message.read"), id: z19.string().min(1).max(40), by: z19.string().min(1) }),
   TaskCmdSchema,
   SessionHandoverSchema,
   ContextSetSchema,
@@ -1101,27 +1170,27 @@ function pickName(taken, preferred) {
 }
 
 // ../protocol/src/proposal.ts
-import { z as z19 } from "zod";
-var ProposalBlockSchema = z19.object({ cwd: z19.string().trim().min(1), prompt: z19.string().optional() });
-var RelayBlockSchema = z19.object({ session: z19.string().trim().min(1), text: z19.string().trim().min(1) });
-var ProjectBlockSchema = z19.object({
-  name: z19.string().trim().min(1).max(80),
-  description: z19.string().max(500).optional(),
-  repos: z19.array(z19.object({ path: z19.string().min(1).max(4096), why: z19.string().trim().min(1).max(200) })).min(1).max(50),
-  addTo: z19.string().trim().max(80).optional()
+import { z as z20 } from "zod";
+var ProposalBlockSchema = z20.object({ cwd: z20.string().trim().min(1), prompt: z20.string().optional() });
+var RelayBlockSchema = z20.object({ session: z20.string().trim().min(1), text: z20.string().trim().min(1) });
+var ProjectBlockSchema = z20.object({
+  name: z20.string().trim().min(1).max(80),
+  description: z20.string().max(500).optional(),
+  repos: z20.array(z20.object({ path: z20.string().min(1).max(4096), why: z20.string().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z20.string().trim().max(80).optional()
 });
-var CloseBlockSchema = z19.object({ session: z19.string().trim().min(1) });
-var TeamBlockSchema = z19.object({
-  cwd: z19.string().trim().min(1),
-  template: z19.string().trim().min(1).max(64).optional(),
-  name: z19.string().trim().min(1).max(60).optional(),
-  seats: z19.array(z19.object({ role: z19.string().trim().min(1).max(40), tool: z19.enum(["claude", "codex", "cursor", "omp"]).optional(), model: z19.string().max(200).optional(), effort: z19.string().max(20).optional(), name: z19.string().max(40).optional() })).min(1).max(8).optional()
+var CloseBlockSchema = z20.object({ session: z20.string().trim().min(1) });
+var TeamBlockSchema = z20.object({
+  cwd: z20.string().trim().min(1),
+  template: z20.string().trim().min(1).max(64).optional(),
+  name: z20.string().trim().min(1).max(60).optional(),
+  seats: z20.array(z20.object({ role: z20.string().trim().min(1).max(40), tool: z20.enum(["claude", "codex", "cursor", "omp"]).optional(), model: z20.string().max(200).optional(), effort: z20.string().max(20).optional(), name: z20.string().max(40).optional() })).min(1).max(8).optional()
 }).refine((b) => !!b.template || !!b.seats?.length, "a template or seats");
-var TaskBlockSchema = z19.object({
-  to: z19.string().trim().min(1).max(80),
-  team: z19.string().trim().max(40).optional(),
-  title: z19.string().trim().min(1).max(200),
-  text: z19.string().max(2e4).optional()
+var TaskBlockSchema = z20.object({
+  to: z20.string().trim().min(1).max(80),
+  team: z20.string().trim().max(40).optional(),
+  title: z20.string().trim().min(1).max(200),
+  text: z20.string().max(2e4).optional()
 });
 var BLOCK = /```ledge-(session|relay|project|close|team|task)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
 function extractProposal(answer) {
@@ -1194,80 +1263,80 @@ function sessionTitle(s) {
 }
 
 // ../protocol/src/relay.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var SEALED_MAX = 1048576;
-var RelayPeerSchema = z20.union([z20.literal("pc"), z20.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
-var RelayClientMessageSchema = z20.object({
-  type: z20.literal("send"),
+var RelayPeerSchema = z21.union([z21.literal("pc"), z21.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
+var RelayClientMessageSchema = z21.object({
+  type: z21.literal("send"),
   to: RelayPeerSchema,
-  body: z20.string().max(SEALED_MAX)
+  body: z21.string().max(SEALED_MAX)
 });
-var RelayServerMessageSchema = z20.discriminatedUnion("type", [
-  z20.object({ type: z20.literal("welcome"), accountId: z20.string(), self: RelayPeerSchema, online: z20.array(RelayPeerSchema) }),
-  z20.object({ type: z20.literal("deliver"), from: RelayPeerSchema, body: z20.string() }),
-  z20.object({ type: z20.literal("presence"), peer: RelayPeerSchema, online: z20.boolean() }),
+var RelayServerMessageSchema = z21.discriminatedUnion("type", [
+  z21.object({ type: z21.literal("welcome"), accountId: z21.string(), self: RelayPeerSchema, online: z21.array(RelayPeerSchema) }),
+  z21.object({ type: z21.literal("deliver"), from: RelayPeerSchema, body: z21.string() }),
+  z21.object({ type: z21.literal("presence"), peer: RelayPeerSchema, online: z21.boolean() }),
   /**
    * A frame was refused; `to` names the target when it is known.
    * Contract: an error concerning a sealed body (`offline`, `too_large`, or a socket closed with 4008
    * `rate_limited`) means that body was not delivered, so the sequence on that channel is lost: the
    * sender must re-handshake with that peer before sending to it again.
    */
-  z20.object({
-    type: z20.literal("error"),
-    code: z20.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
+  z21.object({
+    type: z21.literal("error"),
+    code: z21.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
     to: RelayPeerSchema.optional()
   })
 ]);
 var PAIR_LABEL_MAX = 40;
-var KeyB64 = z20.string().regex(/^[A-Za-z0-9_-]{87}$/);
-var Nonce = z20.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var Fingerprint = z20.string().regex(/^[A-Za-z0-9_-]{22}$/);
-var SealedFrameSchema = z20.discriminatedUnion("k", [
+var KeyB64 = z21.string().regex(/^[A-Za-z0-9_-]{87}$/);
+var Nonce = z21.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var Fingerprint = z21.string().regex(/^[A-Za-z0-9_-]{22}$/);
+var SealedFrameSchema = z21.discriminatedUnion("k", [
   /** `e` is the ephemeral key, `f` the fingerprint of the sender's static key. */
-  z20.object({ k: z20.literal("hello"), e: KeyB64, f: Fingerprint }),
-  z20.object({ k: z20.literal("msg"), s: z20.string() }),
-  z20.object({ k: z20.literal("pair_commit"), c: Nonce, label: z20.string().trim().min(1).max(PAIR_LABEL_MAX) }),
-  z20.object({ k: z20.literal("pair_offer"), pc: KeyB64, n: Nonce }),
-  z20.object({ k: z20.literal("pair_reveal"), d: KeyB64, n: Nonce }),
-  z20.object({ k: z20.literal("pair_ok") }),
-  z20.object({ k: z20.literal("pair_no") }),
-  z20.object({ k: z20.literal("denied") }),
-  z20.object({ k: z20.literal("rekey") })
+  z21.object({ k: z21.literal("hello"), e: KeyB64, f: Fingerprint }),
+  z21.object({ k: z21.literal("msg"), s: z21.string() }),
+  z21.object({ k: z21.literal("pair_commit"), c: Nonce, label: z21.string().trim().min(1).max(PAIR_LABEL_MAX) }),
+  z21.object({ k: z21.literal("pair_offer"), pc: KeyB64, n: Nonce }),
+  z21.object({ k: z21.literal("pair_reveal"), d: KeyB64, n: Nonce }),
+  z21.object({ k: z21.literal("pair_ok") }),
+  z21.object({ k: z21.literal("pair_no") }),
+  z21.object({ k: z21.literal("denied") }),
+  z21.object({ k: z21.literal("rekey") })
 ]);
 
 // ../protocol/src/relayAuth.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var RELAY_CLOSE_SIGNED_OUT = 4001;
-var DeviceStartResponseSchema = z21.object({
-  deviceCode: z21.string().min(1),
-  userCode: z21.string().min(1),
-  verificationUri: z21.string().min(1),
-  expiresIn: z21.number().int().positive(),
-  interval: z21.number().int().positive()
+var DeviceStartResponseSchema = z22.object({
+  deviceCode: z22.string().min(1),
+  userCode: z22.string().min(1),
+  verificationUri: z22.string().min(1),
+  expiresIn: z22.number().int().positive(),
+  interval: z22.number().int().positive()
 });
-var DevicePollResponseSchema = z21.discriminatedUnion("status", [
-  z21.object({ status: z21.literal("pending") }),
-  z21.object({ status: z21.literal("slow_down"), interval: z21.number().int().positive() }),
+var DevicePollResponseSchema = z22.discriminatedUnion("status", [
+  z22.object({ status: z22.literal("pending") }),
+  z22.object({ status: z22.literal("slow_down"), interval: z22.number().int().positive() }),
   /** `token` is the relay session token, shown this once only. */
-  z21.object({ status: z21.literal("ok"), token: z21.string().min(1), accountId: z21.string().min(1), login: z21.string().min(1) }),
-  z21.object({ status: z21.literal("expired") }),
-  z21.object({ status: z21.literal("denied") }),
-  z21.object({ status: z21.literal("not_allowed") })
+  z22.object({ status: z22.literal("ok"), token: z22.string().min(1), accountId: z22.string().min(1), login: z22.string().min(1) }),
+  z22.object({ status: z22.literal("expired") }),
+  z22.object({ status: z22.literal("denied") }),
+  z22.object({ status: z22.literal("not_allowed") })
 ]);
-var DeviceRevokeResponseSchema = z21.object({ revoked: z21.number().int().min(0) });
-var MeResponseSchema = z21.object({
-  accountId: z21.string().min(1),
-  login: z21.string().min(1),
+var DeviceRevokeResponseSchema = z22.object({ revoked: z22.number().int().min(0) });
+var MeResponseSchema = z22.object({
+  accountId: z22.string().min(1),
+  login: z22.string().min(1),
   peer: RelayPeerSchema,
-  kind: z21.enum(["pc", "device"])
+  kind: z22.enum(["pc", "device"])
 });
 
 // ../protocol/src/phone.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // ../protocol/src/push.ts
-import { z as z22 } from "zod";
-var B64U = z22.string().regex(/^[A-Za-z0-9_-]*$/);
+import { z as z23 } from "zod";
+var B64U = z23.string().regex(/^[A-Za-z0-9_-]*$/);
 var PUSH_HOSTS = ["*.push.apple.com", "fcm.googleapis.com", "updates.push.services.mozilla.com", "*.notify.windows.com"];
 function pushEndpointAllowed(url) {
   let u;
@@ -1284,29 +1353,29 @@ function pushEndpointAllowed(url) {
     return host.length > suffix.length && host.endsWith(suffix);
   });
 }
-var PushSendSchema = z22.object({
-  endpoint: z22.string().url().max(1024),
+var PushSendSchema = z23.object({
+  endpoint: z23.string().url().max(1024),
   body: B64U.max(5462),
-  ttl: z22.number().int().min(0).max(86400),
-  urgency: z22.enum(["normal", "high"]),
-  topic: z22.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+  ttl: z23.number().int().min(0).max(86400),
+  urgency: z23.enum(["normal", "high"]),
+  topic: z23.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
 });
-var PushSendResultSchema = z22.object({
-  result: z22.enum(["sent", "gone", "failed"]),
-  status: z22.number().int().optional()
+var PushSendResultSchema = z23.object({
+  result: z23.enum(["sent", "gone", "failed"]),
+  status: z23.number().int().optional()
 });
-var PushSubscriptionSchema = z22.object({
-  endpoint: z22.string().url().max(1024).refine(pushEndpointAllowed),
-  keys: z22.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
+var PushSubscriptionSchema = z23.object({
+  endpoint: z23.string().url().max(1024).refine(pushEndpointAllowed),
+  keys: z23.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
 });
-var PushPayloadSchema = z22.object({
-  v: z22.literal(1),
-  kind: z22.enum(["request", "question", "finished", "chat"]),
-  title: z22.string().max(80),
-  body: z22.string().max(120),
-  url: z22.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
-  badge: z22.number().int().min(0).max(999),
-  tag: z22.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+var PushPayloadSchema = z23.object({
+  v: z23.literal(1),
+  kind: z23.enum(["request", "question", "finished", "chat"]),
+  title: z23.string().max(80),
+  body: z23.string().max(120),
+  url: z23.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
+  badge: z23.number().int().min(0).max(999),
+  tag: z23.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
 });
 
 // ../protocol/src/phone.ts
@@ -1327,22 +1396,22 @@ var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var PENDING_BODY_MAX = 65536;
 var SNAPSHOT_BODY_MAX = 2048;
-var RiskSchema = z23.enum(["low", "high"]);
-var RiskReasonSchema = z23.enum(["question", "read_only_command", "edit_inside_folder", "pushes", "destroys", "deploys", "publishes", "pipes_to_shell", "network", "writes_outside_folder", "sensitive_path", "unsafe_flag", "shell_syntax", "script", "plan", "unknown"]);
-var OperationIdSchema = z23.string().uuid();
-var OperationStatusSchema = z23.enum(["received", "applied", "rejected", "failed"]);
-var OperationReasonSchema = z23.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired"]);
-var CapabilitiesSchema = z23.object({
+var RiskSchema = z24.enum(["low", "high"]);
+var RiskReasonSchema = z24.enum(["question", "read_only_command", "edit_inside_folder", "pushes", "destroys", "deploys", "publishes", "pipes_to_shell", "network", "writes_outside_folder", "sensitive_path", "unsafe_flag", "shell_syntax", "script", "plan", "unknown"]);
+var OperationIdSchema = z24.string().uuid();
+var OperationStatusSchema = z24.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z24.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired"]);
+var CapabilitiesSchema = z24.object({
   /** A question can be answered in free text. */
-  freeTextAnswer: z23.boolean(),
+  freeTextAnswer: z24.boolean(),
   /** The session's accept/deny can be typed; absent = true. */
-  decide: z23.boolean().optional(),
+  decide: z24.boolean().optional(),
   /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z23.boolean().optional()
+  questions: z24.boolean().optional()
 });
 var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
-var CapabilitiesByToolSchema = z23.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
-var PhonePendingSchema = PendingSchema.extend({ key: z23.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z23.literal(true).optional() });
+var CapabilitiesByToolSchema = z24.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z24.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z24.literal(true).optional() });
 var PhoneSessionSchema = SessionSchema.pick({
   id: true,
   name: true,
@@ -1365,202 +1434,210 @@ var PhoneSessionSchema = SessionSchema.pick({
   /** Its context and its relief (context handover spec §3.2): the phone shows the gauge; the relief is started from the PC. */
   context: true,
   relieves: true
-}).extend({ pending: PhonePendingSchema.optional(), unread: z23.boolean(), handover: z23.object({ state: HandoverStateSchema, toName: z23.string().max(80).optional() }).strict().optional() });
-var B64U2 = z23.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z23.object({
+}).extend({ pending: PhonePendingSchema.optional(), unread: z24.boolean(), handover: z24.object({ state: HandoverStateSchema, toName: z24.string().max(80).optional() }).strict().optional() });
+var B64U2 = z24.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z24.object({
   id: B64U2.max(1366),
   publicKey: B64U2.max(2048),
-  alg: z23.union([z23.literal(-7), z23.literal(-257)]),
+  alg: z24.union([z24.literal(-7), z24.literal(-257)]),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
-  transports: z23.array(z23.string().max(20)).max(8).optional()
+  transports: z24.array(z24.string().max(20)).max(8).optional()
 });
-var AssertionSchema = z23.object({
+var AssertionSchema = z24.object({
   id: B64U2.max(1366),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
   signature: B64U2.max(1024)
 });
-var ConfirmPurposeSchema = z23.enum(["register", "decide", "launch", "close"]);
+var ConfirmPurposeSchema = z24.enum(["register", "decide", "launch", "close"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z23.object({
-  project: z23.string().max(80),
+var PhoneChatProposalSchema = z24.object({
+  project: z24.string().max(80),
   tool: ToolSchema,
-  prompt: z23.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z23.string().optional(),
-  failed: z23.literal(true).optional()
+  prompt: z24.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z24.string().optional(),
+  failed: z24.literal(true).optional()
 }).strict();
-var PhoneChatRelaySchema = z23.object({
-  id: z23.string().min(1),
-  name: z23.string(),
+var PhoneChatRelaySchema = z24.object({
+  id: z24.string().min(1),
+  name: z24.string(),
   tool: ToolSchema,
-  text: z23.string().max(TOOL_TEXT_MAX),
-  status: z23.enum(["queued", "sent"]).optional(),
-  sentAt: z23.string().datetime().optional(),
-  failed: z23.literal(true).optional()
+  text: z24.string().max(TOOL_TEXT_MAX),
+  status: z24.enum(["queued", "sent"]).optional(),
+  sentAt: z24.string().datetime().optional(),
+  failed: z24.literal(true).optional()
 }).strict();
-var PhoneChatCloseSchema = z23.object({
-  id: z23.string().min(1),
-  name: z23.string(),
+var PhoneChatCloseSchema = z24.object({
+  id: z24.string().min(1),
+  name: z24.string(),
   tool: ToolSchema,
-  how: z23.enum(["exit", "killed"]).optional(),
-  closedAt: z23.string().datetime().optional(),
-  failed: z23.literal(true).optional()
+  how: z24.enum(["exit", "killed"]).optional(),
+  closedAt: z24.string().datetime().optional(),
+  failed: z24.literal(true).optional()
 }).strict();
-var PhoneChatTeamSchema = z23.object({
-  project: z23.string().max(80),
-  name: z23.string().max(60),
-  template: z23.string().max(64).optional(),
-  seats: z23.array(z23.object({ role: z23.string().max(40), label: z23.string().max(40), tool: ToolSchema, model: z23.string().max(200).optional(), effort: z23.string().max(20).optional(), autonomy: AutonomySchema.optional() }).strict()).min(1).max(8),
-  teamId: z23.string().max(40).optional(),
-  launchedAt: z23.string().datetime().optional(),
-  failed: z23.literal(true).optional()
+var PhoneChatTeamSchema = z24.object({
+  project: z24.string().max(80),
+  name: z24.string().max(60),
+  template: z24.string().max(64).optional(),
+  seats: z24.array(z24.object({ role: z24.string().max(40), label: z24.string().max(40), tool: ToolSchema, model: z24.string().max(200).optional(), effort: z24.string().max(20).optional(), autonomy: AutonomySchema.optional() }).strict()).min(1).max(8),
+  teamId: z24.string().max(40).optional(),
+  launchedAt: z24.string().datetime().optional(),
+  failed: z24.literal(true).optional()
 }).strict();
-var PhoneChatTaskSchema = z23.object({
-  to: z23.string().max(80),
-  toName: z23.string().max(80).optional(),
-  title: z23.string().max(200),
-  text: z23.string().max(TOOL_TEXT_MAX).optional(),
-  taskId: z23.string().max(40).optional(),
-  ownerName: z23.string().max(80).optional(),
-  state: z23.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  failed: z23.literal(true).optional()
+var PhoneChatTaskSchema = z24.object({
+  to: z24.string().max(80),
+  toName: z24.string().max(80).optional(),
+  title: z24.string().max(200),
+  text: z24.string().max(TOOL_TEXT_MAX).optional(),
+  taskId: z24.string().max(40).optional(),
+  ownerName: z24.string().max(80).optional(),
+  state: z24.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  failed: z24.literal(true).optional()
 }).strict();
-var PhoneTeamSchema = z23.object({
-  id: z23.string().max(40),
-  name: z23.string().max(60),
-  project: z23.string().max(80).nullable(),
-  state: z23.enum(["active", "resting"]),
-  seats: z23.array(z23.object({ role: z23.string().max(40), sessionId: z23.string().max(100).nullable() }).strict()).max(16),
-  done: z23.number().int().min(0),
-  given: z23.number().int().min(0)
+var PhoneTeamSchema = z24.object({
+  id: z24.string().max(40),
+  name: z24.string().max(60),
+  project: z24.string().max(80).nullable(),
+  state: z24.enum(["active", "resting"]),
+  seats: z24.array(z24.object({ role: z24.string().max(40), sessionId: z24.string().max(100).nullable() }).strict()).max(16),
+  done: z24.number().int().min(0),
+  given: z24.number().int().min(0)
 }).strict();
-var PhoneTaskSchema = z23.object({
-  id: z23.string().max(40),
-  title: z23.string().max(200),
-  owner: z23.string().max(100),
-  ownerName: z23.string().max(80),
-  ownerRole: z23.string().max(40).optional(),
-  team: z23.string().max(40).optional(),
-  teamName: z23.string().max(60).optional(),
-  state: z23.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z23.string().max(TOOL_TEXT_MAX).optional(),
-  cut: z23.literal(true).optional(),
-  at: z23.string(),
-  updatedAt: z23.string(),
-  seen: z23.literal(true).optional()
+var PhoneTaskSchema = z24.object({
+  id: z24.string().max(40),
+  title: z24.string().max(200),
+  owner: z24.string().max(100),
+  ownerName: z24.string().max(80),
+  ownerRole: z24.string().max(40).optional(),
+  team: z24.string().max(40).optional(),
+  teamName: z24.string().max(60).optional(),
+  state: z24.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z24.string().max(TOOL_TEXT_MAX).optional(),
+  cut: z24.literal(true).optional(),
+  at: z24.string(),
+  updatedAt: z24.string(),
+  seen: z24.literal(true).optional()
 }).strict();
-var ChatErrorCodeSchema = z23.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z23.object({
+var ChatErrorCodeSchema = z24.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z24.object({
   qid: OperationIdSchema,
-  question: z23.string().max(MESSAGE_MAX),
-  askedAt: z23.string().datetime(),
-  steps: z23.array(PhoneChatStepSchema).max(50),
-  answer: z23.string().max(THREAD_TEXT_MAX).optional(),
-  answeredAt: z23.string().datetime().optional(),
+  question: z24.string().max(MESSAGE_MAX),
+  askedAt: z24.string().datetime(),
+  steps: z24.array(PhoneChatStepSchema).max(50),
+  answer: z24.string().max(THREAD_TEXT_MAX).optional(),
+  answeredAt: z24.string().datetime().optional(),
   error: ChatErrorCodeSchema.optional(),
-  proposals: z23.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  proposals: z24.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
   relay: PhoneChatRelaySchema.optional(),
-  closes: z23.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
-  cut: z23.literal(true).optional(),
+  closes: z24.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
+  cut: z24.literal(true).optional(),
   team: PhoneChatTeamSchema.optional(),
-  tasks: z23.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional()
+  tasks: z24.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
+  attachments: z24.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
 }).strict();
 var CHAT_HISTORY_BUDGET = 393216;
-var sessionId = z23.string().min(1).max(100);
-var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z23.string().min(1).max(64) });
-var CardRowsSchema = z23.array(z23.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var PhoneClientMessageSchema = z23.discriminatedUnion("type", [
-  z23.object({ type: z23.literal("snapshot.request") }),
-  z23.object({ type: z23.literal("session.thread"), id: sessionId }),
+var sessionId = z24.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z24.string().min(1).max(64) });
+var CardRowsSchema = z24.array(z24.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var PhoneClientMessageSchema = z24.discriminatedUnion("type", [
+  z24.object({ type: z24.literal("snapshot.request") }),
+  z24.object({ type: z24.literal("session.thread"), id: sessionId }),
   /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
-  z23.object({ type: z23.literal("session.pending"), id: sessionId }),
+  z24.object({ type: z24.literal("session.pending"), id: sessionId }),
   /** The session whose terminal the phone shows; null when it shows none. */
-  z23.object({ type: z23.literal("session.watch"), id: sessionId.nullable() }),
-  z23.object({ type: z23.literal("session.read"), id: sessionId, at: z23.string().datetime() }),
+  z24.object({ type: z24.literal("session.watch"), id: sessionId.nullable() }),
+  z24.object({ type: z24.literal("session.read"), id: sessionId, at: z24.string().datetime() }),
   /** Asks for a challenge. One object for both purposes: the gateway refuses a `decide` without `id` and `expect`. */
-  z23.object({ type: z23.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
-  z23.object({ type: z23.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z23.object({
-    type: z23.literal("session.decide"),
+  z24.object({ type: z24.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
+  z24.object({ type: z24.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z24.object({
+    type: z24.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z23.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z24.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the phone showed: refused unless it is still the pending one. */
     expect: PhoneExpectSchema,
     /** The device check over the challenge of `confirm.prepare`; required by the daemon for a high-risk accept. */
     assertion: AssertionSchema.optional()
   }),
-  z23.object({
-    type: z23.literal("session.reply"),
+  z24.object({
+    type: z24.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z23.string().min(1).max(MESSAGE_MAX),
+    text: z24.string().max(MESSAGE_MAX),
+    attachments: z24.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
     /** The request the reply answers, or null when the phone showed none: refused if the session's request is no longer that one. */
     expect: PhoneExpectSchema.nullable(),
     assertion: AssertionSchema.optional()
   }),
   /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order; `cancel` declines it. Bounds as the local `session.answer`. */
-  z23.object({
-    type: z23.literal("session.answer"),
+  z24.object({
+    type: z24.literal("session.answer"),
     op: OperationIdSchema,
     id: sessionId,
-    requestId: z23.string().min(1).max(200),
-    answers: z23.array(z23.object({ id: z23.string().max(200), selected: z23.array(z23.string().max(2e3)).max(100), text: z23.string().max(2e4).optional() })).max(50),
-    cancel: z23.literal(true).optional(),
+    requestId: z24.string().min(1).max(200),
+    answers: z24.array(z24.object({ id: z24.string().max(200), selected: z24.array(z24.string().max(2e3)).max(100), text: z24.string().max(2e4).optional() })).max(50),
+    cancel: z24.literal(true).optional(),
     expect: PhoneExpectSchema
   }),
-  z23.object({ type: z23.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  z24.object({ type: z24.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
   /** The phone drops its passkey from the daemon. */
-  z23.object({ type: z23.literal("device.forget"), op: OperationIdSchema }),
+  z24.object({ type: z24.literal("device.forget"), op: OperationIdSchema }),
   /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z23.object({ type: z23.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
-  z23.object({ type: z23.literal("push.unsubscribe"), op: OperationIdSchema }),
+  z24.object({ type: z24.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z24.object({ type: z24.literal("push.unsubscribe"), op: OperationIdSchema }),
   /** The phone's own chat with Ledge. */
-  z23.object({ type: z23.literal("chat.ask"), qid: OperationIdSchema, text: z23.string().trim().min(1).max(MESSAGE_MAX) }),
-  z23.object({ type: z23.literal("chat.cancel"), qid: OperationIdSchema }),
-  z23.object({ type: z23.literal("chat.reset") }),
-  z23.object({ type: z23.literal("chat.history") }),
-  z23.object({ type: z23.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
-  z23.object({ type: z23.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
-  z23.object({ type: z23.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z24.object({ type: z24.literal("chat.ask"), qid: OperationIdSchema, text: z24.string().trim().max(MESSAGE_MAX), attachments: z24.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
+  z24.object({ type: z24.literal("chat.cancel"), qid: OperationIdSchema }),
+  z24.object({ type: z24.literal("chat.reset") }),
+  z24.object({ type: z24.literal("chat.history") }),
+  /** An image to store, sent alone before the message that names it; no `id`, and at most `ATTACHMENT_MAX` bytes. */
+  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z24.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
+  AttachmentGetSchema.pick({ type: true, requestId: true, attachment: true, preview: true }),
+  z24.object({ type: z24.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z24.object({ type: z24.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z24.object({ type: z24.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
   /** The turn's team card (roles spec §3.8): launched like a session card, with the device check (purpose `launch`, the turn). */
-  z23.object({ type: z23.literal("chat.team"), op: OperationIdSchema, qid: OperationIdSchema, assertion: AssertionSchema.optional() }),
+  z24.object({ type: z24.literal("chat.team"), op: OperationIdSchema, qid: OperationIdSchema, assertion: AssertionSchema.optional() }),
   /** A row of the turn's task card: given by Ledge. */
-  z23.object({ type: z23.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z23.number().int().min(0).max(MAX_PROPOSALS - 1) }),
+  z24.object({ type: z24.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z24.number().int().min(0).max(MAX_PROPOSALS - 1) }),
   /** « Reprendre » a resting team. */
-  z23.object({ type: z23.literal("team.resume"), op: OperationIdSchema, team: z23.string().min(1).max(40) }),
+  z24.object({ type: z24.literal("team.resume"), op: OperationIdSchema, team: z24.string().min(1).max(40) }),
   /** Puts a closed task Ledge gave away from « À traiter ». */
-  z23.object({ type: z23.literal("task.seen"), op: OperationIdSchema, task: z23.string().min(1).max(40) }),
+  z24.object({ type: z24.literal("task.seen"), op: OperationIdSchema, task: z24.string().min(1).max(40) }),
   /** Whether the phone's app is in front: a device that is visible gets no push. */
-  z23.object({ type: z23.literal("presence"), visible: z23.boolean() })
+  z24.object({ type: z24.literal("presence"), visible: z24.boolean() })
 ]);
-var PhoneServerMessageSchema = z23.discriminatedUnion("type", [
-  z23.object({ type: z23.literal("snapshot"), protocol: z23.literal(PHONE_PROTOCOL), sessions: z23.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z23.object({ version: z23.string(), name: z23.string().max(40), boot: z23.string().uuid().optional() }), device: z23.object({ confirm: z23.boolean(), push: z23.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z23.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
-  z23.object({ type: z23.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z23.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z23.number().int().positive() }),
-  z23.object({ type: z23.literal("session.updated"), session: PhoneSessionSchema }),
-  z23.object({ type: z23.literal("session.removed"), id: z23.string() }),
+var PhoneServerMessageSchema = z24.discriminatedUnion("type", [
+  z24.object({ type: z24.literal("snapshot"), protocol: z24.literal(PHONE_PROTOCOL), sessions: z24.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z24.object({ version: z24.string(), name: z24.string().max(40), boot: z24.string().uuid().optional() }), device: z24.object({ confirm: z24.boolean(), push: z24.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z24.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  z24.object({ type: z24.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z24.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z24.number().int().positive() }),
+  z24.object({ type: z24.literal("session.updated"), session: PhoneSessionSchema }),
+  z24.object({ type: z24.literal("session.removed"), id: z24.string() }),
   /** `pending.cut` is set when even this body was shortened. */
-  z23.object({ type: z23.literal("session.pending"), id: z23.string(), pending: PhonePendingSchema }),
-  z23.object({ type: z23.literal("session.preview"), id: z23.string(), lines: z23.array(z23.string()) }),
+  z24.object({ type: z24.literal("session.pending"), id: z24.string(), pending: PhonePendingSchema }),
+  z24.object({ type: z24.literal("session.preview"), id: z24.string(), lines: z24.array(z24.string()) }),
   /** `cut`: the ids of the items shortened; `more`: older items were left out. */
-  z23.object({ type: z23.literal("session.thread"), id: z23.string(), items: z23.array(ThreadItemSchema), cut: z23.array(z23.string()), more: z23.boolean() }),
-  z23.object({ type: z23.literal("session.thread.item"), id: z23.string(), item: ThreadItemSchema, cut: z23.literal(true).optional() }),
-  z23.object({ type: z23.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
-  z23.object({ type: z23.literal("chat.history"), turns: z23.array(PhoneChatTurnSchema).max(50) }),
-  z23.object({ type: z23.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  z24.object({ type: z24.literal("session.thread"), id: z24.string(), items: z24.array(ThreadItemSchema), cut: z24.array(z24.string()), more: z24.boolean() }),
+  z24.object({ type: z24.literal("session.thread.item"), id: z24.string(), item: ThreadItemSchema, cut: z24.literal(true).optional() }),
+  z24.object({ type: z24.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
+  z24.object({ type: z24.literal("chat.history"), turns: z24.array(PhoneChatTurnSchema).max(50) }),
+  z24.object({ type: z24.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
   /** The whole text so far, not an increment. */
-  z23.object({ type: z23.literal("chat.delta"), qid: OperationIdSchema, text: z23.string().max(THREAD_TEXT_MAX) }),
-  z23.object({ type: z23.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
-  z23.object({ type: z23.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
+  z24.object({ type: z24.literal("chat.delta"), qid: OperationIdSchema, text: z24.string().max(THREAD_TEXT_MAX) }),
+  z24.object({ type: z24.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z24.object({ type: z24.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
   /** The live teams, after each snapshot and on every change. */
-  z23.object({ type: z23.literal("teams"), teams: z23.array(PhoneTeamSchema).max(50) }),
+  z24.object({ type: z24.literal("teams"), teams: z24.array(PhoneTeamSchema).max(50) }),
   /** The tasks Ledge gave, open or closed lately, after each snapshot; then each change. */
-  z23.object({ type: z23.literal("tasks"), tasks: z23.array(PhoneTaskSchema).max(200) }),
-  z23.object({ type: z23.literal("task.updated"), task: PhoneTaskSchema }),
+  z24.object({ type: z24.literal("tasks"), tasks: z24.array(PhoneTaskSchema).max(200) }),
+  z24.object({ type: z24.literal("task.updated"), task: PhoneTaskSchema }),
+  AttachmentStoredSchema,
+  AttachmentDataSchema,
+  AttachmentErrorSchema,
   /** Never carries free text. */
-  z23.object({ type: z23.literal("error"), code: z23.enum(["invalid", "unknown_session", "too_large"]), request: z23.string().max(40).optional() })
+  z24.object({ type: z24.literal("error"), code: z24.enum(["invalid", "unknown_session", "too_large"]), request: z24.string().max(40).optional() })
 ]);
 
 // src/auth.ts
@@ -1683,6 +1760,12 @@ function readDaemonToken() {
 }
 
 export {
+  ATTACHMENT_ID,
+  ATTACHMENT_MAX,
+  ATTACHMENT_LOCAL_MAX,
+  PREVIEW_MAX,
+  ATTACHMENTS_MAX,
+  AttachmentRefSchema,
   CONTEXT_NEAR,
   CONTEXT_NEAR_MIN,
   CONTEXT_NEAR_MAX,
@@ -1711,13 +1794,14 @@ export {
   ModelIdSchema,
   EffortSchema,
   RouteResultSchema,
-  DEFAULT_RELAY_URL,
-  MobileConfigSchema,
   TASK_TITLE_MAX,
   TASK_TEXT_MAX,
   LEDGE_GIVER,
+  transmissions,
   givenByLedge,
   taskClosed,
+  DEFAULT_RELAY_URL,
+  MobileConfigSchema,
   ROLE_LABEL_MAX,
   ROLE_PROMPT_MAX,
   RoleSchema,