@paradow/ledge 0.34.0 → 0.35.0

package/dist/cli/{chunk-IWY7DSSO.js → reduceWorker.js}

@@ -1,126 +1,168 @@
-import {
-  paths
-} from "./chunk-53ISXX2R.js";
+// src/daemon/reduceWorker.ts
+import { parentPort } from "worker_threads";
 
-// ../protocol/src/handover.ts
+// src/daemon/attachments.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readdir, readFile, rename, stat, unlink, utimes, writeFile } from "fs/promises";
+import { join } from "path";
+
+// ../protocol/src/attachments.ts
 import { z } from "zod";
-var ContextSchema = z.object({ used: z.number().int().min(0), window: z.number().int().positive(), at: z.string().datetime() });
-var CONTEXT_NEAR = 0.8;
+var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
+var AttachmentIdSchema = z.string().regex(ATTACHMENT_ID);
+var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
+var ImageMimeSchema = z.enum(IMAGE_MIMES);
+var ATTACHMENT_MAX = 4e5;
+var ATTACHMENT_LOCAL_MAX = 2e6;
+var PREVIEW_MAX = 4e4;
+var CAPTURE_RAW_MAX = 28e5;
+var ATTACHMENTS_MAX = 5;
+var IMAGE_LONG_SIDE = 1600;
+var PREVIEW_LONG_SIDE = 480;
+var b64Max = (bytes) => Math.ceil(bytes / 3) * 4;
+var AttachmentRefSchema = z.object({
+  id: AttachmentIdSchema,
+  mime: ImageMimeSchema,
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  bytes: z.number().int().positive(),
+  preview: z.boolean()
+});
+var ImageUploadSchema = z.object({
+  mime: ImageMimeSchema,
+  data: z.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
+  preview: z.object({ mime: ImageMimeSchema, data: z.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
+});
+var AttachmentErrorReasonSchema = z.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
+var requestId = z.string().min(1).max(100);
+var AttachmentPutSchema = z.object({ type: z.literal("attachment.put"), requestId, id: z.string().optional(), image: ImageUploadSchema });
+var AttachmentGetSchema = z.object({ type: z.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z.boolean().optional(), id: z.string().optional(), machine: z.string().optional() });
+var AttachmentCaptureSchema = z.object({ type: z.literal("attachment.capture"), requestId, image: z.object({ mime: ImageMimeSchema, data: z.string().min(1).max(b64Max(CAPTURE_RAW_MAX)) }) });
+var AttachmentStoredSchema = z.object({ type: z.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
+var AttachmentDataSchema = z.object({ type: z.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z.string() });
+var AttachmentErrorSchema = z.object({ type: z.literal("attachment.error"), requestId, reason: AttachmentErrorReasonSchema });
+
+// ../protocol/src/chat.ts
+import { z as z9 } from "zod";
+
+// ../protocol/src/session.ts
+import { z as z3 } from "zod";
+
+// ../protocol/src/handover.ts
+import { z as z2 } from "zod";
+var ContextSchema = z2.object({ used: z2.number().int().min(0), window: z2.number().int().positive(), at: z2.string().datetime() });
 var CONTEXT_NEAR_MIN = 0.5;
 var CONTEXT_NEAR_MAX = 0.95;
-var ContextPrefsSchema = z.object({ near: z.number().min(CONTEXT_NEAR_MIN).max(CONTEXT_NEAR_MAX) });
-var contextShare = (c) => c ? Math.min(1, c.used / c.window) : void 0;
-var contextNear = (c, near = CONTEXT_NEAR) => (contextShare(c) ?? 0) >= near;
-var HandoverStateSchema = z.enum(["briefing", "launching", "done", "failed"]);
-var HandoverSchema = z.object({
+var ContextPrefsSchema = z2.object({ near: z2.number().min(CONTEXT_NEAR_MIN).max(CONTEXT_NEAR_MAX) });
+var HandoverStateSchema = z2.enum(["briefing", "launching", "done", "failed"]);
+var HandoverSchema = z2.object({
   state: HandoverStateSchema,
-  at: z.string().datetime(),
+  at: z2.string().datetime(),
   /** The relief, once launched. */
-  to: z.string().optional(),
-  toName: z.string().optional(),
-  reason: z.string().optional(),
+  to: z2.string().optional(),
+  toName: z2.string().optional(),
+  reason: z2.string().optional(),
   /** Started by Ledge itself (a session working without asking), not by the user. */
-  auto: z.literal(true).optional()
+  auto: z2.literal(true).optional()
 });
-var RelievesSchema = z.object({ id: z.string(), name: z.string(), at: z.string().datetime() });
+var RelievesSchema = z2.object({ id: z2.string(), name: z2.string(), at: z2.string().datetime() });
 var BRIEF_MAX = 2e4;
-var ContextSetSchema = z.object({ type: z.literal("context.set"), prefs: ContextPrefsSchema });
-var ContextPrefsMessageSchema = z.object({ type: z.literal("context.prefs"), prefs: ContextPrefsSchema });
-var SessionHandoverSchema = z.object({ type: z.literal("session.handover"), rid: z.string().min(1).max(100), id: z.string().min(1) });
-var HandoverBriefSchema = z.object({ type: z.literal("handover.brief"), rid: z.string().min(1).max(100), by: z.string().min(1), text: z.string().min(1).max(BRIEF_MAX) });
-var HandoverShowSchema = z.object({ type: z.literal("handover.show"), rid: z.string().min(1).max(100), by: z.string().min(1) });
-var SessionHandoverResultSchema = z.object({ type: z.literal("session.handover.result"), rid: z.string(), ok: z.boolean(), reason: z.string().optional() });
-var HandoverResultSchema = z.object({ type: z.literal("handover.result"), rid: z.string(), text: z.string().optional(), reason: z.string().optional() });
+var ContextSetSchema = z2.object({ type: z2.literal("context.set"), prefs: ContextPrefsSchema });
+var ContextPrefsMessageSchema = z2.object({ type: z2.literal("context.prefs"), prefs: ContextPrefsSchema });
+var SessionHandoverSchema = z2.object({ type: z2.literal("session.handover"), rid: z2.string().min(1).max(100), id: z2.string().min(1) });
+var HandoverBriefSchema = z2.object({ type: z2.literal("handover.brief"), rid: z2.string().min(1).max(100), by: z2.string().min(1), text: z2.string().min(1).max(BRIEF_MAX) });
+var HandoverShowSchema = z2.object({ type: z2.literal("handover.show"), rid: z2.string().min(1).max(100), by: z2.string().min(1) });
+var SessionHandoverResultSchema = z2.object({ type: z2.literal("session.handover.result"), rid: z2.string(), ok: z2.boolean(), reason: z2.string().optional() });
+var HandoverResultSchema = z2.object({ type: z2.literal("handover.result"), rid: z2.string(), text: z2.string().optional(), reason: z2.string().optional() });
 
 // ../protocol/src/session.ts
-import { z as z2 } from "zod";
-var ToolSchema = z2.enum(["claude", "codex", "cursor", "omp"]);
-var OmpApprovalSchema = z2.enum(["always-ask", "write", "yolo"]);
-var BackendSchema = z2.enum(["tmux", "omp-rpc"]);
-var SessionStateSchema = z2.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
-var AskQuestionSchema = z2.object({
-  id: z2.string(),
-  question: z2.string(),
-  header: z2.string().optional(),
-  multi: z2.boolean().optional(),
-  options: z2.array(z2.object({ label: z2.string(), description: z2.string().optional() }))
-});
-var PendingSchema = z2.object({
-  kind: z2.enum(["question", "permission", "plan", "diff"]),
-  text: z2.string(),
+var ToolSchema = z3.enum(["claude", "codex", "cursor", "omp"]);
+var OmpApprovalSchema = z3.enum(["always-ask", "write", "yolo"]);
+var BackendSchema = z3.enum(["tmux", "omp-rpc"]);
+var SessionStateSchema = z3.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
+var AskQuestionSchema = z3.object({
+  id: z3.string(),
+  question: z3.string(),
+  header: z3.string().optional(),
+  multi: z3.boolean().optional(),
+  options: z3.array(z3.object({ label: z3.string(), description: z3.string().optional() }))
+});
+var PendingSchema = z3.object({
+  kind: z3.enum(["question", "permission", "plan", "diff"]),
+  text: z3.string(),
   /** What to review in full before deciding, when `text` is only its summary: a plan's markdown. */
-  body: z2.string().optional(),
-  tool: z2.string().optional(),
-  options: z2.array(z2.string()).optional(),
+  body: z3.string().optional(),
+  tool: z3.string().optional(),
+  options: z3.array(z3.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z2.array(z2.string()).optional(),
+  optionDetails: z3.array(z3.string()).optional(),
   /** `rpc`: the harness's own protocol asked (OMP): answered on its request id, never by typing. */
-  source: z2.enum(["hook", "pane", "rpc"]),
+  source: z3.enum(["hook", "pane", "rpc"]),
   /** OMP: every question of one `ask` call, answered together with `session.answer`; `requestId` is the dialog it answers. */
-  questions: z2.array(AskQuestionSchema).optional(),
-  requestId: z2.string().optional(),
+  questions: z3.array(AskQuestionSchema).optional(),
+  requestId: z3.string().optional(),
   /** Set when the request comes from a helper (subagent): it is routed through its parent. */
-  helperId: z2.string().optional(),
+  helperId: z3.string().optional(),
   /** For a helper-routed request: the state the parent returns to once it is answered (main thread may stop meanwhile). */
   parentState: SessionStateSchema.optional()
 });
-var ReplySchema = z2.object({
-  text: z2.string(),
-  at: z2.string().datetime(),
+var ReplySchema = z3.object({
+  text: z3.string(),
+  at: z3.string().datetime(),
   /** The reply is a plan the agent proposes (Codex Plan mode): nothing in it is done yet. */
-  plan: z2.boolean().optional()
+  plan: z3.boolean().optional()
 });
-var HelperSchema = z2.object({
-  id: z2.string(),
-  kind: z2.string(),
-  task: z2.string(),
+var HelperSchema = z3.object({
+  id: z3.string(),
+  kind: z3.string(),
+  task: z3.string(),
   state: SessionStateSchema,
   /** When this helper finished; retained across daemon restarts until its five-minute expiry. */
-  finishedAt: z2.string().datetime().optional()
+  finishedAt: z3.string().datetime().optional()
 });
-var TopicSourceSchema = z2.enum(["user", "pane", "prompt"]);
-var SessionSchema = z2.object({
+var TopicSourceSchema = z3.enum(["user", "pane", "prompt"]);
+var SessionSchema = z3.object({
   /** Origin is annotated by the overlay, never used as an unqualified session id on the wire. */
-  machineId: z2.string().optional(),
-  machineName: z2.string().optional(),
-  repoId: z2.string().optional(),
+  machineId: z3.string().optional(),
+  machineName: z3.string().optional(),
+  repoId: z3.string().optional(),
   /** Annotated by the fleet when its machine is unreachable and the last snapshot is kept (keepStale, spec 2026-10-14 §6). */
-  offline: z2.boolean().optional(),
-  id: z2.string().min(1),
-  name: z2.string().min(1),
+  offline: z3.boolean().optional(),
+  id: z3.string().min(1),
+  name: z3.string().min(1),
   tool: ToolSchema,
-  cwd: z2.string(),
-  project: z2.string(),
-  title: z2.string(),
+  cwd: z3.string(),
+  project: z3.string(),
+  title: z3.string(),
   /** One line saying what the session is about (spec 2026-10-11 §3). */
-  topic: z2.string().optional(),
+  topic: z3.string().optional(),
   topicSource: TopicSourceSchema.optional(),
   /** The repository (its main worktree's folder name and absolute path), the checked-out branch, and whether `cwd` is a linked worktree (§4). */
-  repo: z2.string().optional(),
-  repoPath: z2.string().optional(),
-  branch: z2.string().optional(),
-  worktree: z2.boolean().optional(),
+  repo: z3.string().optional(),
+  repoPath: z3.string().optional(),
+  branch: z3.string().optional(),
+  worktree: z3.boolean().optional(),
   /** The folder the agent works in now, as its last hook reported it: `cwd` stays where it started, this follows a worktree it entered. */
-  workdir: z2.string().optional(),
+  workdir: z3.string().optional(),
   /** The OpenRig seat this agent is: its session name (`dev-build@starter`), its rig, and its role (`dev.build`) once OpenRig named it. */
-  rig: z2.object({ seat: z2.string(), name: z2.string(), role: z2.string().optional() }).optional(),
-  tmuxSession: z2.string().nullable(),
+  rig: z3.object({ seat: z3.string(), name: z3.string(), role: z3.string().optional() }).optional(),
+  tmuxSession: z3.string().nullable(),
   /** Left out for a tmux session. `omp-rpc`: no pane, nothing to attach to; the daemon holds the process (see `agentSessionFile`). */
   backend: BackendSchema.optional(),
   state: SessionStateSchema,
   pending: PendingSchema.optional(),
-  helpers: z2.array(HelperSchema).default([]),
+  helpers: z3.array(HelperSchema).default([]),
   /** OMP: the instructions waiting in its own queue (typed while it works), as it reports them; left out when none. */
-  queue: z2.array(z2.object({ text: z2.string(), mode: z2.enum(["steer", "follow_up"]) })).optional(),
+  queue: z3.array(z3.object({ text: z3.string(), mode: z3.enum(["steer", "follow_up"]) })).optional(),
   lastReply: ReplySchema.optional(),
   /** The last message this session sent to another agent: its tool_use_id, the address, the peer's Ledge session id, a one-line summary. */
-  lastMessage: z2.object({ id: z2.string(), to: z2.string(), peer: z2.string().optional(), summary: z2.string(), at: z2.string().datetime() }).optional(),
-  startedAt: z2.string().datetime(),
-  lastActivityAt: z2.string().datetime(),
-  lastHookAt: z2.string().datetime().optional(),
+  lastMessage: z3.object({ id: z3.string(), to: z3.string(), peer: z3.string().optional(), summary: z3.string(), at: z3.string().datetime() }).optional(),
+  startedAt: z3.string().datetime(),
+  lastActivityAt: z3.string().datetime(),
+  lastHookAt: z3.string().datetime().optional(),
   /** The model and effort Ledge launched the agent with (#58); left out, the agent's own default. */
-  model: z2.string().optional(),
-  effort: z2.string().optional(),
+  model: z3.string().optional(),
+  effort: z3.string().optional(),
   /** OMP: the approval mode it was launched with, kept by a resume; left out, `always-ask`. */
   approval: OmpApprovalSchema.optional(),
   /** Its context as its agent last reported it, after a turn (context handover spec §3.1); left out, not measured. */
@@ -130,218 +172,136 @@ var SessionSchema = z2.object({
   /** The session it relieves, when it is a relief. */
   relieves: RelievesSchema.optional(),
   /** A model change asked while the agent worked (`session.model`), applied at its next free moment; a field left out is the agent's default. */
-  modelNext: z2.object({ model: z2.string().optional(), effort: z2.string().optional() }).optional(),
+  modelNext: z3.object({ model: z3.string().optional(), effort: z3.string().optional() }).optional(),
   /** The agent's own session id when Ledge chose it at launch (Claude Code `--session-id`). */
-  agentSessionId: z2.string().optional(),
+  agentSessionId: z3.string().optional(),
   /** OMP: the exact journal file of the conversation, what a resume names (never "the latest of the folder"). */
-  agentSessionFile: z2.string().optional(),
+  agentSessionFile: z3.string().optional(),
   /** The agent's transcript: the latest one a hook named (it follows /clear and --resume), else the one the launch implies. */
-  transcriptPath: z2.string().optional(),
-  exitCode: z2.number().int().nullable().optional(),
-  exitedAt: z2.string().datetime().optional(),
-  lastError: z2.string().optional(),
+  transcriptPath: z3.string().optional(),
+  exitCode: z3.number().int().nullable().optional(),
+  exitedAt: z3.string().datetime().optional(),
+  lastError: z3.string().optional(),
   /** `launcher`: Ledge launched it; `hook_only`: only its hooks are known (read-only); `rig`: an OpenRig seat Ledge follows through
    *  its tmux pane on the user's default server, answered like its own, whose life stays OpenRig's (no close, kill, resume, model). */
   // A kind a newer daemon adds reads as read-only here, never as a snapshot thrown away whole (« hors ligne »).
-  source: z2.enum(["launcher", "hook_only", "rig"]).catch("hook_only"),
+  source: z3.enum(["launcher", "hook_only", "rig"]).catch("hook_only"),
   /** When the session was put in the archive (session management): set, it leaves the live list and waits to be restored, resumed or deleted. */
-  archivedAt: z2.string().datetime().optional(),
+  archivedAt: z3.string().datetime().optional(),
   /** When the session was last taken out of the archive: the poller's retirement clock restarts from it, not from `exitedAt`. */
-  restoredAt: z2.string().datetime().optional()
-});
-function backendOf(s) {
-  return s.backend ?? "tmux";
-}
-function isArchived(s) {
-  return s.archivedAt !== void 0;
-}
-
-// ../protocol/src/tasks.ts
-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(),
-  text: z3.string().optional(),
-  giver: z3.string(),
-  giverName: z3.string(),
-  owner: z3.string(),
-  ownerName: z3.string(),
-  state: z3.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z3.string().optional(),
-  /** A task Ledge gave and the user put away from « À toi » once closed. */
-  seen: z3.boolean().optional(),
-  at: z3.string(),
-  updatedAt: 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 openDecision = (t) => t.owner === LEDGE_GIVER && !taskClosed(t);
-var TaskCmdSchema = z3.object({
-  type: z3.literal("task.cmd"),
-  rid: z3.string().min(1),
-  by: z3.string().min(1),
-  op: z3.enum(["give", "take", "done", "refuse", "pass", "show", "list", "seen", "cancel"]),
-  task: z3.string().min(1).max(40).optional(),
-  to: z3.string().min(1).optional(),
-  title: z3.string().min(1).max(TASK_TITLE_MAX).optional(),
-  text: z3.string().max(TASK_TEXT_MAX).optional(),
-  all: z3.boolean().optional(),
-  qid: z3.string().min(1).optional(),
-  row: z3.number().int().min(0).max(7).optional()
-});
-var TaskUpdatedSchema = z3.object({ type: z3.literal("task.updated"), task: TaskSchema });
-var TaskResultSchema = z3.object({
-  type: z3.literal("task.result"),
-  rid: z3.string(),
-  task: TaskSchema.optional(),
-  tasks: z3.array(TaskSchema).optional(),
-  reason: z3.string().optional()
+  restoredAt: z3.string().datetime().optional()
 });
 
-// ../protocol/src/actions.ts
-import { z as z7 } from "zod";
-
-// ../protocol/src/proposal.ts
-import { z as z4 } from "zod";
-var ProposalBlockSchema = z4.object({ cwd: z4.string().trim().min(1), prompt: z4.string().optional() });
-var RelayBlockSchema = z4.object({ session: z4.string().trim().min(1), text: z4.string().trim().min(1) });
-var ProjectBlockSchema = z4.object({
-  name: z4.string().trim().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().trim().min(1).max(200) })).min(1).max(50),
-  addTo: z4.string().trim().max(80).optional()
-});
-var CloseBlockSchema = z4.object({ session: z4.string().trim().min(1) });
-var TaskBlockSchema = z4.object({
-  to: z4.string().trim().min(1).max(80),
-  title: z4.string().trim().min(1).max(200),
-  text: z4.string().max(2e4).optional()
-});
-var BLOCK = /```ledge-(session|relay|project|close|task|action)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
-function extractProposal(answer) {
-  const found = [];
-  const text2 = answer.replace(BLOCK, (_m, kind, body) => {
-    found.push({ kind, raw: body.trim() });
-    return "";
-  });
-  const last = found.at(-1);
-  return last ? { text: text2.replace(/\n{3,}/g, "\n\n").trim(), kind: last.kind, raw: last.raw, blocks: found } : { text: answer, kind: null, raw: null, blocks: [] };
-}
-function parseRelayBlock(raw) {
-  try {
-    const r = RelayBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseCloseBlock(raw) {
-  try {
-    const r = CloseBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseTaskBlock(raw) {
-  try {
-    const r = TaskBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseProjectBlock(raw) {
-  try {
-    const r = ProjectBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-
 // ../protocol/src/models.ts
-import { z as z5 } from "zod";
-var ModelIdSchema = z5.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
-var EffortSchema = z5.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
-var ModelChoiceSchema = z5.object({
+import { z as z4 } from "zod";
+var ModelIdSchema = z4.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
+var EffortSchema = z4.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
+var ModelChoiceSchema = z4.object({
   id: ModelIdSchema,
-  label: z5.string(),
-  description: z5.string().optional(),
-  efforts: z5.array(EffortSchema).optional(),
+  label: z4.string(),
+  description: z4.string().optional(),
+  efforts: z4.array(EffortSchema).optional(),
   defaultEffort: EffortSchema.optional(),
-  isDefault: z5.boolean().optional()
+  isDefault: z4.boolean().optional()
 });
-var ModelsListSchema = z5.object({
-  type: z5.literal("models.list"),
-  requestId: z5.string().min(1).max(100),
+var ModelsListSchema = z4.object({
+  type: z4.literal("models.list"),
+  requestId: z4.string().min(1).max(100),
   tool: ToolSchema,
-  machineId: z5.string().optional()
+  machineId: z4.string().optional()
 });
-var ModelsListingSchema = z5.object({
-  type: z5.literal("models.listing"),
-  requestId: z5.string(),
+var ModelsListingSchema = z4.object({
+  type: z4.literal("models.listing"),
+  requestId: z4.string(),
   tool: ToolSchema,
-  models: z5.array(ModelChoiceSchema),
-  error: z5.string().optional()
+  models: z4.array(ModelChoiceSchema),
+  error: z4.string().optional()
+});
+var ModelRefusalSchema = z4.enum(["not_launched", "ended", "no_conversation", "not_running", "effort_in_model", "restart_failed", "refused"]);
+var SessionModelAcceptedSchema = z4.object({ type: z4.literal("session.model.accepted"), id: z4.string(), when: z4.enum(["now", "turn", "none"]) });
+
+// ../protocol/src/actions.ts
+import { z as z8 } from "zod";
+
+// ../protocol/src/proposal.ts
+import { z as z5 } from "zod";
+var ProposalBlockSchema = z5.object({ cwd: z5.string().trim().min(1), prompt: z5.string().optional() });
+var RelayBlockSchema = z5.object({ session: z5.string().trim().min(1), text: z5.string().trim().min(1) });
+var ProjectBlockSchema = z5.object({
+  name: z5.string().trim().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().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z5.string().trim().max(80).optional()
+});
+var CloseBlockSchema = z5.object({ session: z5.string().trim().min(1) });
+var TaskBlockSchema = z5.object({
+  to: z5.string().trim().min(1).max(80),
+  title: z5.string().trim().min(1).max(200),
+  text: z5.string().max(2e4).optional()
 });
-var ModelRefusalSchema = z5.enum(["not_launched", "ended", "no_conversation", "not_running", "effort_in_model", "restart_failed", "refused"]);
-var SessionModelAcceptedSchema = z5.object({ type: z5.literal("session.model.accepted"), id: z5.string(), when: z5.enum(["now", "turn", "none"]) });
 
 // ../protocol/src/decisions.ts
 import { z as z6 } from "zod";
 var DecisionSchema = z6.enum(["accept", "deny", "always"]);
 var NOTE_MAX = 4e3;
-var NOTE_NOT_TYPED = "note_not_typed";
-var DECISION_OFFERS = {
-  claude: { always: ["permission", "diff", "plan"], note: ["permission", "diff", "plan"] },
-  codex: { always: ["permission", "diff"], note: ["permission", "diff", "plan"] },
-  cursor: { always: [], note: ["permission", "plan"] },
-  /** OMP answers its own native requests (spec 2026-10-20 §3.3): no « always », no note until those are typed. */
-  omp: { always: [], note: [] }
-};
-function offers(tool, kind, what) {
-  return DECISION_OFFERS[tool][what].includes(kind);
-}
-function cyrb53(str, seed) {
-  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
-  for (let i = 0; i < str.length; i++) {
-    const ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
-}
-function pendingKey(p) {
-  const s = JSON.stringify([p.kind, p.text, p.body ?? null, p.tool ?? null, p.options ?? null, p.optionDetails ?? null, p.helperId ?? null]);
-  return cyrb53(s, 0) + cyrb53(s, 1);
-}
+
+// ../protocol/src/tasks.ts
+import { z as z7 } from "zod";
+var TASK_TITLE_MAX = 200;
+var TASK_TEXT_MAX = 2e4;
+var TASK_OPS = ["give", "take", "pass", "done", "refuse", "cancel", "drop"];
+var TRANSMISSION_OPS = ["give", "pass", "done", "refuse", "cancel"];
+var TaskLogEntrySchema = z7.object({
+  at: z7.string(),
+  by: z7.string(),
+  what: z7.string(),
+  op: z7.enum(TASK_OPS).optional(),
+  from: z7.string().optional(),
+  to: z7.string().optional(),
+  fromName: z7.string().optional(),
+  toName: z7.string().optional(),
+  note: z7.string().optional()
+});
+var TaskSchema = z7.object({
+  id: z7.string(),
+  title: z7.string(),
+  text: z7.string().optional(),
+  giver: z7.string(),
+  giverName: z7.string(),
+  owner: z7.string(),
+  ownerName: z7.string(),
+  state: z7.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z7.string().optional(),
+  /** A task Ledge gave and the user put away from « À toi » once closed. */
+  seen: z7.boolean().optional(),
+  at: z7.string(),
+  updatedAt: z7.string(),
+  log: z7.array(TaskLogEntrySchema)
+});
+var TaskCmdSchema = z7.object({
+  type: z7.literal("task.cmd"),
+  rid: z7.string().min(1),
+  by: z7.string().min(1),
+  op: z7.enum(["give", "take", "done", "refuse", "pass", "show", "list", "seen", "cancel"]),
+  task: z7.string().min(1).max(40).optional(),
+  to: z7.string().min(1).optional(),
+  title: z7.string().min(1).max(TASK_TITLE_MAX).optional(),
+  text: z7.string().max(TASK_TEXT_MAX).optional(),
+  all: z7.boolean().optional(),
+  qid: z7.string().min(1).optional(),
+  row: z7.number().int().min(0).max(7).optional()
+});
+var TaskUpdatedSchema = z7.object({ type: z7.literal("task.updated"), task: TaskSchema });
+var TaskResultSchema = z7.object({
+  type: z7.literal("task.result"),
+  rid: z7.string(),
+  task: TaskSchema.optional(),
+  tasks: z7.array(TaskSchema).optional(),
+  reason: z7.string().optional()
+});
 
 // ../protocol/src/actions.ts
-var ActionRiskSchema = z7.enum(["read", "reversible", "destructive"]);
+var ActionRiskSchema = z8.enum(["read", "reversible", "destructive"]);
 var ACTION_IDS = [
   "session.launch",
   "session.relay",
@@ -358,10 +318,10 @@ var ACTION_IDS = [
   "task.pass",
   "task.answer"
 ];
-var ActionIdSchema = z7.enum(ACTION_IDS);
+var ActionIdSchema = z8.enum(ACTION_IDS);
 var def = (d) => d;
-var SessionRef = z7.string().trim().min(1).max(80);
-var TaskRef = z7.string().trim().min(1).max(40);
+var SessionRef = z8.string().trim().min(1).max(80);
+var TaskRef = z8.string().trim().min(1).max(40);
 var LaunchArgs = ProposalBlockSchema.extend({ model: ModelIdSchema.optional(), effort: EffortSchema.optional() });
 var ACTIONS = [
   def({
@@ -427,14 +387,14 @@ var ACTIONS = [
     phone: null,
     risk: "reversible",
     max: 8,
-    args: z7.object({ session: SessionRef, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+    args: z8.object({ session: SessionRef, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
     summary: "changer le mod\xE8le et l'effort d'une session en cours (null : le d\xE9faut de l'agent) ; elle red\xE9marre sur la m\xEAme conversation, \xE0 son prochain moment libre",
     when: "quand l'utilisateur demande de passer une session sur un autre mod\xE8le ou un autre effort",
     example: { session: "Nova", model: "claude-opus-5-5", effort: "high" }
   }),
   def({
     id: "session.interrupt",
-    args: z7.object({ session: SessionRef }),
+    args: z8.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -445,7 +405,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.archive",
-    args: z7.object({ session: SessionRef }),
+    args: z8.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -456,7 +416,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.restore",
-    args: z7.object({ session: SessionRef }),
+    args: z8.object({ session: SessionRef }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -467,7 +427,7 @@ var ACTIONS = [
   }),
   def({
     id: "session.resume",
-    args: z7.object({ session: SessionRef }),
+    args: z8.object({ session: SessionRef }),
     card: "generic",
     phone: "act",
     risk: "reversible",
@@ -481,7 +441,7 @@ var ACTIONS = [
     card: "generic",
     phone: "act",
     max: 1,
-    args: z7.object({ session: SessionRef, decision: z7.enum(["accept", "deny"]), note: z7.string().trim().min(1).max(NOTE_MAX).optional() }),
+    args: z8.object({ session: SessionRef, decision: z8.enum(["accept", "deny"]), note: z8.string().trim().min(1).max(NOTE_MAX).optional() }),
     risk: (a) => a.decision === "accept" ? "destructive" : "reversible",
     summary: "accepter ou refuser la demande en attente d'une session (permission, diff ou plan), note possible avec un refus ; jamais \xAB toujours \xBB",
     when: "seulement quand l'utilisateur demande explicitement d'accepter ou de refuser la demande d'une session pr\xE9cise, et que sessions.md montre une demande en attente pour elle ; cite la demande telle quelle dans ta r\xE9ponse",
@@ -489,7 +449,7 @@ var ACTIONS = [
   }),
   def({
     id: "task.cancel",
-    args: z7.object({ task: TaskRef, reason: z7.string().trim().min(1).max(500).optional() }),
+    args: z8.object({ task: TaskRef, reason: z8.string().trim().min(1).max(500).optional() }),
     card: "generic",
     phone: "act",
     risk: "destructive",
@@ -500,7 +460,7 @@ var ACTIONS = [
   }),
   def({
     id: "task.pass",
-    args: z7.object({ task: TaskRef, to: SessionRef, note: z7.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
+    args: z8.object({ task: TaskRef, to: SessionRef, note: z8.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
     card: "generic",
     phone: null,
     risk: "reversible",
@@ -511,7 +471,7 @@ var ACTIONS = [
   }),
   def({
     id: "task.answer",
-    args: z7.object({ task: TaskRef, answer: z7.string().trim().min(1).max(TASK_TEXT_MAX) }),
+    args: z8.object({ task: TaskRef, answer: z8.string().trim().min(1).max(TASK_TEXT_MAX) }),
     card: "generic",
     phone: "act",
     risk: "destructive",
@@ -522,436 +482,95 @@ var ACTIONS = [
   })
 ];
 var byId = new Map(ACTIONS.map((a) => [a.id, a]));
-var actionById = (id) => byId.get(id);
-var riskOf = (a, args) => typeof a.risk === "function" ? a.risk(args) : a.risk;
-var ActionBlockSchema = z7.object({ action: z7.string().trim().min(1).max(40), args: z7.record(z7.unknown()).default({}) });
-var LEGACY_FENCE_ACTION = {
-  session: "session.launch",
-  relay: "session.relay",
-  close: "session.close",
-  project: "project.propose",
-  task: "task.give"
-};
-function parseActionBlock(kind, raw) {
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch {
-    return { error: "invalid JSON" };
-  }
-  let id;
-  let args;
-  if (kind === "action") {
-    const b = ActionBlockSchema.safeParse(json);
-    if (!b.success) return { error: "not an {action, args} object" };
-    id = b.data.action;
-    args = b.data.args;
-  } else {
-    id = LEGACY_FENCE_ACTION[kind];
-    args = json;
-  }
-  const action = actionById(id);
-  if (!action) return { error: `unknown action ${id}` };
-  const parsed = action.args.safeParse(args);
-  if (!parsed.success) return { error: `invalid args for ${id}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"} ${i.message}`).join("; ")}` };
-  return { action, args: parsed.data };
-}
-var NEVER_PROPOSED = [
-  "tuer (kill) ou supprimer une session, la retirer de la liste",
-  "mettre \xE0 jour le daemon",
-  "changer les machines, les r\xE9glages, l'acc\xE8s mobile",
-  "modifier les projets autrement que par la carte de projet",
-  "cr\xE9er un dossier",
-  "r\xE9pondre \xAB toujours \xBB \xE0 une demande, ou r\xE9pondre aux questions \xE0 choix d'OMP"
-];
-
-// ../protocol/src/openrig.ts
-import { z as z8 } from "zod";
-var RigNameSchema = z8.string().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a rig name");
-var RigSeatNameSchema = z8.string().min(3).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a seat");
-var SeatPermissionsSchema = z8.enum(["inherit", "floor", "auto", "full_bypass"]);
-var KERNEL_RIG = "kernel";
-var RigSeatSchema = z8.object({
-  logicalId: z8.string(),
-  session: z8.string(),
-  runtime: z8.string(),
-  model: z8.string().nullable(),
-  sessionStatus: z8.string(),
-  lifecycleState: z8.string(),
-  activity: z8.string(),
-  stopped: z8.boolean(),
-  work: z8.number().int().min(0)
-});
-var RigSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
-  status: z8.string(),
-  lifecycleState: z8.string(),
-  seats: z8.number().int().min(0),
-  running: z8.number().int().min(0),
-  attention: z8.number().int().min(0),
-  uptime: z8.string().nullable(),
-  snapshot: z8.string().nullable(),
-  nodes: z8.array(RigSeatSchema)
-});
-var RigDaemonStateSchema = z8.enum(["running", "stopped", "stale", "unknown"]);
-var RigKernelStateSchema = z8.enum(["ready", "starting", "stopped", "skipped", "absent", "unknown"]);
-var OpenRigStateSchema = z8.object({
-  installed: z8.boolean(),
-  version: z8.string().optional(),
-  daemon: z8.object({ state: RigDaemonStateSchema, pid: z8.number().int().optional(), port: z8.number().int().optional(), message: z8.string().optional() }),
-  kernel: z8.object({ state: RigKernelStateSchema }),
-  rigs: z8.array(RigSchema),
-  /** When it was read (ISO). */
-  at: z8.string()
-});
-var OpenRigActionSchema = z8.discriminatedUnion("kind", [
-  /** `restore` `last`: `rig start --last` (the rigs that were running come back); `none`: `rig daemon start`. */
-  z8.object({ kind: z8.literal("daemon.start"), restore: z8.enum(["last", "none"]).optional(), noKernel: z8.boolean().optional() }),
-  z8.object({ kind: z8.literal("daemon.stop") }),
-  z8.object({ kind: z8.literal("daemon.restart"), restore: z8.enum(["last", "none"]).optional() }),
-  z8.object({ kind: z8.literal("kernel.start") }),
-  z8.object({ kind: z8.literal("kernel.stop") }),
-  z8.object({ kind: z8.literal("kernel.restart") }),
-  z8.object({ kind: z8.literal("rig.start"), rig: RigNameSchema }),
-  z8.object({ kind: z8.literal("rig.stop"), rig: RigNameSchema, snapshot: z8.boolean().optional(), force: z8.boolean().optional(), delete: z8.boolean().optional() }),
-  z8.object({ kind: z8.literal("rig.restart"), rig: RigNameSchema }),
-  /** A seat's settings (docs/mockups/ledge-openrig-groups.html, view 2). `runtime`: moves it now to the other harness (a successor
-   *  takes its context, `rig seat set-runtime`), `model` and `effort` going with it; without it, `model`, `effort` and `permissions`
-   *  apply at its next resume. `dryRun`: the move's plan only. */
-  z8.object({
-    kind: z8.literal("seat.set"),
-    seat: RigSeatNameSchema,
-    runtime: z8.enum(["claude-code", "codex"]).optional(),
-    model: ModelIdSchema.optional(),
-    effort: EffortSchema.optional(),
-    permissions: SeatPermissionsSchema.optional(),
-    dryRun: z8.boolean().optional()
-  })
-]);
-var OpenRigStatusSchema = z8.object({ type: z8.literal("openrig.status"), requestId: z8.string().min(1).max(100), machineId: z8.string().optional() });
-var OpenRigActSchema = z8.object({ type: z8.literal("openrig.act"), requestId: z8.string().min(1).max(100), action: OpenRigActionSchema, machineId: z8.string().optional() });
-var OpenRigUnreachableSchema = z8.enum(["offline", "outdated"]);
-var OpenRigStateMessageSchema = z8.object({
-  type: z8.literal("openrig.state"),
-  requestId: z8.string().optional(),
-  machineId: z8.string().optional(),
-  state: OpenRigStateSchema.optional(),
-  error: OpenRigUnreachableSchema.optional()
-});
-var OpenRigDoneSchema = z8.object({
-  type: z8.literal("openrig.done"),
-  requestId: z8.string(),
-  machineId: z8.string().optional(),
-  ok: z8.boolean(),
-  commands: z8.array(z8.string()),
-  output: z8.string().optional(),
-  error: z8.string().optional()
-});
-function rigCommands(a) {
-  const start = (restore, noKernel) => restore === "last" ? ["start", "--last", "--json"] : ["daemon", "start", ...noKernel ? ["--no-kernel"] : []];
-  const up = (rig) => ["up", rig, "--existing", "--yes", "--json"];
-  const down = (rig, o = {}) => ["down", rig, ...o.snapshot ? ["--snapshot"] : [], ...o.force ? ["--force"] : [], ...o.delete ? ["--delete"] : [], "--json"];
-  switch (a.kind) {
-    case "daemon.start":
-      return [start(a.restore, a.noKernel)];
-    case "daemon.stop":
-      return [["daemon", "stop"]];
-    case "daemon.restart":
-      return [["daemon", "stop"], start(a.restore)];
-    case "kernel.start":
-      return [up(KERNEL_RIG)];
-    case "kernel.stop":
-      return [down(KERNEL_RIG)];
-    case "kernel.restart":
-      return [down(KERNEL_RIG, { snapshot: true }), up(KERNEL_RIG)];
-    case "rig.start":
-      return [up(a.rig)];
-    case "rig.stop":
-      return [down(a.rig, a)];
-    case "rig.restart":
-      return [down(a.rig, { snapshot: true }), up(a.rig)];
-    case "seat.set": {
-      const why = ["--reason", "Ledge"];
-      if (a.runtime) return [[
-        "seat",
-        "set-runtime",
-        a.seat,
-        "--runtime",
-        a.runtime,
-        ...a.model ? ["--model", a.model] : [],
-        ...a.effort ? ["--effort", a.effort] : [],
-        ...a.permissions && a.permissions !== "inherit" ? ["--permission-mode", a.permissions] : [],
-        ...a.dryRun ? ["--dry-run"] : [],
-        ...why
-      ]];
-      return [
-        ...a.model ? [["seat", "set-model", a.seat, "--model", a.model, ...why, "--json"]] : [],
-        ...a.effort ? [["seat", "set-effort", a.seat, "--effort", a.effort, ...why, "--json"]] : [],
-        ...a.permissions ? [["seat", "set-permissions", a.seat, "--mode", a.permissions, ...why, "--json"]] : []
-      ];
-    }
-  }
-}
-var showRigCommand = (args) => ["rig", ...args.filter((x) => x !== "--json")].join(" ");
-var RigSpecMemberSchema = z8.object({
-  id: z8.string(),
-  runtime: z8.string(),
-  model: z8.string().optional(),
-  agent: z8.string(),
-  /** Its `permission_policy`, as written. */
-  policy: z8.string().optional()
-});
-var RigSpecPodSchema = z8.object({ id: z8.string(), label: z8.string().optional(), members: z8.array(RigSpecMemberSchema) });
-var RigSpecSchema = z8.object({
-  name: z8.string(),
-  source: z8.string(),
-  summary: z8.string().optional(),
-  path: z8.string(),
-  /** The rig's `permission_policy`, as written (`builtin:auto`, a file…). */
-  policy: z8.string().optional(),
-  pods: z8.array(RigSpecPodSchema),
-  edges: z8.number().int().min(0)
-});
-var OpenRigSpecsSchema = z8.object({ type: z8.literal("openrig.specs"), requestId: z8.string().min(1).max(100), machineId: z8.string().optional() });
-var OpenRigSpecListSchema = z8.object({
-  type: z8.literal("openrig.specList"),
-  requestId: z8.string(),
-  machineId: z8.string().optional(),
-  specs: z8.array(RigSpecSchema),
-  error: z8.string().optional()
-});
-var RigRoleSchema = z8.string().min(3).max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*\.[A-Za-z0-9][A-Za-z0-9_-]*$/, "not a role");
-var RuntimeSchema = z8.enum(["claude-code", "codex"]);
-var RigPolicySchema = z8.enum(["auto", "standard", "open", "yolo", "locked"]);
-var RIG_POLICIES = RigPolicySchema.options;
-var RigLaunchSchema = z8.object({
-  spec: RigNameSchema,
-  cwd: z8.string().min(1).max(4096),
-  name: RigNameSchema,
-  seats: z8.record(RigRoleSchema, z8.number().int().min(0).max(9)).optional(),
-  runtimes: z8.record(RigRoleSchema, RuntimeSchema).optional(),
-  models: z8.record(RigRoleSchema, z8.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/)).optional(),
-  delegation: z8.enum(["pairs", "all"]).optional(),
-  save: z8.boolean().optional(),
-  plan: z8.boolean().optional(),
-  /** The rig's permission policy, in place of the spec's; `policies`: a role's, over the rig's. */
-  policy: RigPolicySchema.optional(),
-  policies: z8.record(RigRoleSchema, RigPolicySchema).optional(),
-  /** Accept the harnesses' first-launch warnings (`rig up --non-interruptive`), so a bypassing seat does not stop on Claude's dialog. */
-  nonInterruptive: z8.boolean().optional()
-});
-var OpenRigLaunchSchema = z8.object({ type: z8.literal("openrig.launch"), requestId: z8.string().min(1).max(100), launch: RigLaunchSchema, machineId: z8.string().optional() });
-var OpenRigLaunchedSchema = z8.object({
-  type: z8.literal("openrig.launched"),
-  requestId: z8.string(),
-  machineId: z8.string().optional(),
-  ok: z8.boolean(),
-  plan: z8.boolean(),
-  commands: z8.array(z8.string()),
-  yaml: z8.string().optional(),
-  seats: z8.number().int().optional(),
-  output: z8.string().optional(),
-  error: z8.string().optional(),
-  /** What `rig up --plan` concluded: its status (`planned`…), its errors and its warnings (one per seat without a permission policy…). */
-  check: z8.object({ status: z8.string(), errors: z8.array(z8.string()), warnings: z8.array(z8.string()) }).optional()
-});
-var roleOf = (logicalId) => logicalId.replace(/-\d+$/, "");
-var copyOf = (logicalId) => {
-  const m = /-(\d+)$/.exec(logicalId);
-  return m ? Number(m[1]) : 1;
-};
-function seatsByRole(nodes) {
-  const out = /* @__PURE__ */ new Map();
-  for (const n of nodes) out.set(roleOf(n.logicalId), [...out.get(roleOf(n.logicalId)) ?? [], n.logicalId]);
-  for (const [role, ids] of out) out.set(role, ids.sort((a, b) => copyOf(a) - copyOf(b)));
-  return out;
-}
-function seatPlan(nodes, seats) {
-  const by = seatsByRole(nodes);
-  const add = [], remove = [];
-  for (const [role, want] of Object.entries(seats)) {
-    const have = by.get(role) ?? [];
-    if (have.length === 0) continue;
-    if (want < have.length) {
-      remove.push(...have.slice(want).reverse());
-      continue;
-    }
-    const [pod, member] = role.split(".");
-    let next = Math.max(...have.map(copyOf));
-    for (let i = have.length; i < want; i++) add.push({ role, pod, id: `${member}-${++next}`, from: have[0] });
-  }
-  return { add, remove };
-}
-var OpenRigSeatsSchema = z8.object({
-  type: z8.literal("openrig.seats"),
-  requestId: z8.string().min(1).max(100),
-  machineId: z8.string().optional(),
-  rig: RigNameSchema,
-  seats: z8.record(RigRoleSchema, z8.number().int().min(0).max(9)),
-  /** How the added seats are linked, where OpenRig can add links to a running rig (0.7+): like a launch's. */
-  delegation: z8.enum(["pairs", "all"]).optional()
-});
-var OpenRigReseatedSchema = z8.object({
-  type: z8.literal("openrig.reseated"),
-  requestId: z8.string(),
-  machineId: z8.string().optional(),
-  ok: z8.boolean(),
-  commands: z8.array(z8.string()),
-  added: z8.array(z8.string()),
-  removed: z8.array(z8.string()),
-  output: z8.string().optional(),
-  error: z8.string().optional(),
-  /** The links ensured between the seats; `linksUnsupported`: this OpenRig cannot add links to a running rig (before 0.7). */
-  links: z8.number().int().optional(),
-  linksUnsupported: z8.boolean().optional()
-});
-
-// ../protocol/src/messages.ts
-import { z as z21 } from "zod";
+var ActionBlockSchema = z8.object({ action: z8.string().trim().min(1).max(40), args: z8.record(z8.unknown()).default({}) });
 
 // ../protocol/src/chat.ts
-import { z as z10 } from "zod";
-
-// ../protocol/src/attachments.ts
-import { z as z9 } from "zod";
-var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
-var AttachmentIdSchema = z9.string().regex(ATTACHMENT_ID);
-var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
-var ImageMimeSchema = z9.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 = z9.object({
-  id: AttachmentIdSchema,
-  mime: ImageMimeSchema,
-  width: z9.number().int().positive(),
-  height: z9.number().int().positive(),
-  bytes: z9.number().int().positive(),
-  preview: z9.boolean()
-});
-var ImageUploadSchema = z9.object({
-  mime: ImageMimeSchema,
-  data: z9.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
-  preview: z9.object({ mime: ImageMimeSchema, data: z9.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
-});
-var AttachmentErrorReasonSchema = z9.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
-var requestId = z9.string().min(1).max(100);
-var AttachmentPutSchema = z9.object({ type: z9.literal("attachment.put"), requestId, id: z9.string().optional(), image: ImageUploadSchema });
-var AttachmentGetSchema = z9.object({ type: z9.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z9.boolean().optional(), id: z9.string().optional(), machine: z9.string().optional() });
-var AttachmentStoredSchema = z9.object({ type: z9.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
-var AttachmentDataSchema = z9.object({ type: z9.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z9.string() });
-var AttachmentErrorSchema = z9.object({ type: z9.literal("attachment.error"), requestId, reason: AttachmentErrorReasonSchema });
-
-// ../protocol/src/chat.ts
-var ChatStepSchema = z10.object({
-  kind: z10.enum(["sessions", "pane", "reply", "git", "repo"]),
-  id: z10.string().optional(),
-  name: z10.string().optional(),
-  path: z10.string().optional()
-});
-var ChatProposalSchema = z10.object({
-  cwd: z10.string().min(1),
-  project: z10.string(),
-  prompt: z10.string().optional(),
+var ChatStepSchema = z9.object({
+  kind: z9.enum(["sessions", "pane", "reply", "git", "repo"]),
+  id: z9.string().optional(),
+  name: z9.string().optional(),
+  path: z9.string().optional()
+});
+var ChatProposalSchema = z9.object({
+  cwd: z9.string().min(1),
+  project: z9.string(),
+  prompt: z9.string().optional(),
   tool: ToolSchema,
   /** What Ledge proposed on the card's picker (spec 2026-10-26 action registry §4), the agent's own default when left out. */
   model: ModelIdSchema.optional(),
   effort: EffortSchema.optional(),
-  launchedId: z10.string().optional(),
-  error: z10.string().optional()
+  launchedId: z9.string().optional(),
+  error: z9.string().optional()
 });
 var MAX_PROPOSALS = 8;
-var ChatProposalsSchema = z10.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatRelaySchema = z10.object({
-  id: z10.string().min(1),
-  name: z10.string(),
+var ChatProposalsSchema = z9.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatRelaySchema = z9.object({
+  id: z9.string().min(1),
+  name: z9.string(),
   tool: ToolSchema,
-  text: z10.string().min(1),
-  status: z10.enum(["queued", "sent"]).optional(),
-  sentAt: z10.string().datetime().optional(),
-  error: z10.string().optional(),
+  text: z9.string().min(1),
+  status: z9.enum(["queued", "sent"]).optional(),
+  sentAt: z9.string().datetime().optional(),
+  error: z9.string().optional(),
   /** Why it failed, as a code a front words itself (a RefusalCode, `ended`, or `failed` for the machinery); goes with `error`. */
-  code: z10.string().max(40).optional()
+  code: z9.string().max(40).optional()
 });
-var ChatCloseSchema = z10.object({
-  id: z10.string().min(1),
-  name: z10.string(),
+var ChatCloseSchema = z9.object({
+  id: z9.string().min(1),
+  name: z9.string(),
   tool: ToolSchema,
-  closedAt: z10.string().datetime().optional(),
-  how: z10.enum(["exit", "killed"]).optional(),
-  error: z10.string().optional()
-});
-var ChatClosesSchema = z10.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
-var ChatProjectProposalSchema = z10.object({
-  name: z10.string().min(1).max(80),
-  description: z10.string().max(500).optional(),
-  repos: z10.array(z10.object({ path: z10.string().min(1).max(4096), why: z10.string().min(1).max(200) })).min(1).max(50),
-  addTo: z10.string().min(1).max(80).optional()
-});
-var ChatTaskProposalSchema = z10.object({
-  to: z10.string().min(1),
-  toName: z10.string().optional(),
-  title: z10.string().min(1).max(200),
-  text: z10.string().max(2e4).optional(),
-  taskId: z10.string().optional(),
-  ownerName: z10.string().optional(),
-  state: z10.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  givenAt: z10.string().datetime().optional(),
-  error: z10.string().optional()
-});
-var ChatTasksSchema = z10.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
-var ActionVarsSchema = z10.record(z10.string().max(40), z10.string().max(300));
+  closedAt: z9.string().datetime().optional(),
+  how: z9.enum(["exit", "killed"]).optional(),
+  error: z9.string().optional()
+});
+var ChatClosesSchema = z9.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
+var ChatProjectProposalSchema = z9.object({
+  name: z9.string().min(1).max(80),
+  description: z9.string().max(500).optional(),
+  repos: z9.array(z9.object({ path: z9.string().min(1).max(4096), why: z9.string().min(1).max(200) })).min(1).max(50),
+  addTo: z9.string().min(1).max(80).optional()
+});
+var ChatTaskProposalSchema = z9.object({
+  to: z9.string().min(1),
+  toName: z9.string().optional(),
+  title: z9.string().min(1).max(200),
+  text: z9.string().max(2e4).optional(),
+  taskId: z9.string().optional(),
+  ownerName: z9.string().optional(),
+  state: z9.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  givenAt: z9.string().datetime().optional(),
+  error: z9.string().optional()
+});
+var ChatTasksSchema = z9.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
+var ActionVarsSchema = z9.record(z9.string().max(40), z9.string().max(300));
 var DETAIL_MAX = 4e3;
-var ACTION_ERROR_CODES = [
-  "unknown",
-  "ambiguous",
-  "read_only",
-  "exited",
-  "running",
-  "archived",
-  "not_archived",
-  "no_terminal",
-  "same_model",
-  "no_request",
-  "in_session",
-  "no_note",
-  "closed",
-  "holder",
-  "changed",
-  "cut",
-  "not_decision",
-  "failed"
-];
-var ChatActionStateSchema = z10.enum(["running", "done", "denied", "failed", "refused"]);
-var ChatActionSchema = z10.object({
-  action: z10.string().min(1).max(40),
-  args: z10.record(z10.unknown()),
-  summary: z10.string().min(1).max(300),
+var ChatActionStateSchema = z9.enum(["running", "done", "denied", "failed", "refused"]);
+var ChatActionSchema = z9.object({
+  action: z9.string().min(1).max(40),
+  args: z9.record(z9.unknown()),
+  summary: z9.string().min(1).max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z10.string().max(DETAIL_MAX).optional(),
-  detailCut: z10.literal(true).optional(),
+  detail: z9.string().max(DETAIL_MAX).optional(),
+  detailCut: z9.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z10.string().optional(),
+  session: z9.string().optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z10.string().datetime().optional(),
-  error: z10.string().optional(),
-  code: z10.string().max(40).optional()
-});
-var ChatActionsSchema = z10.array(ChatActionSchema).min(1).max(MAX_PROPOSALS);
-var ChatTurnSchema = z10.object({
-  machineId: z10.string().optional(),
-  machineName: z10.string().optional(),
-  choices: z10.array(z10.object({ id: z10.string(), label: z10.string() })).optional(),
-  qid: z10.string().min(1),
-  question: z10.string(),
-  askedAt: z10.string().datetime(),
-  steps: z10.array(ChatStepSchema),
-  answer: z10.string().optional(),
-  answeredAt: z10.string().datetime().optional(),
-  error: z10.string().optional(),
+  doneAt: z9.string().datetime().optional(),
+  error: z9.string().optional(),
+  code: z9.string().max(40).optional()
+});
+var ChatActionsSchema = z9.array(ChatActionSchema).min(1).max(MAX_PROPOSALS);
+var ChatTurnSchema = z9.object({
+  machineId: z9.string().optional(),
+  machineName: z9.string().optional(),
+  choices: z9.array(z9.object({ id: z9.string(), label: z9.string() })).optional(),
+  qid: z9.string().min(1),
+  question: z9.string(),
+  askedAt: z9.string().datetime(),
+  steps: z9.array(ChatStepSchema),
+  answer: z9.string().optional(),
+  answeredAt: z9.string().datetime().optional(),
+  error: z9.string().optional(),
   proposal: ChatProposalSchema.optional(),
   proposals: ChatProposalsSchema.optional(),
   relay: ChatRelaySchema.optional(),
@@ -959,50 +578,31 @@ var ChatTurnSchema = z10.object({
   projectProposal: ChatProjectProposalSchema.optional(),
   tasks: ChatTasksSchema.optional(),
   actions: ChatActionsSchema.optional(),
-  ignoredAt: z10.string().datetime().optional(),
-  attachments: z10.array(AttachmentRefSchema).optional()
+  ignoredAt: z9.string().datetime().optional(),
+  attachments: z9.array(AttachmentRefSchema).optional()
 });
-var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
-
-// ../protocol/src/repos.ts
-import { z as z11 } from "zod";
-var ReposInspectSchema = z11.object({
-  type: z11.literal("repos.inspect"),
-  requestId: z11.string().min(1).max(100),
-  paths: z11.array(z11.string().min(1)).min(1).max(50),
-  machineId: z11.string().optional()
-});
-var RepoInfoSchema = z11.object({ path: z11.string(), exists: z11.boolean(), branch: z11.string().nullable() });
-var ReposInfoSchema = z11.object({ type: z11.literal("repos.info"), requestId: z11.string(), repos: z11.array(RepoInfoSchema) });
-
-// ../protocol/src/scan.ts
-import { z as z12 } from "zod";
-var ReposScanSchema = z12.object({ type: z12.literal("repos.scan"), requestId: z12.string().min(1).max(100), machineId: z12.string().optional() });
-var FoundRepoSchema = z12.object({ path: z12.string(), branch: z12.string().nullable(), remote: z12.string().optional(), manifest: z12.string().max(200).optional() });
-var ReposFoundSchema = z12.object({ type: z12.literal("repos.found"), requestId: z12.string(), repos: z12.array(FoundRepoSchema).max(500), truncated: z12.boolean(), error: z12.string().optional() });
 
 // ../protocol/src/documents.ts
-import { z as z13 } from "zod";
-var DOCUMENT_MAX_BYTES = 1048576;
-var path = z13.string().min(1).max(4096);
-var requestId2 = z13.string().min(1);
-var DocumentReadSchema = z13.object({
-  type: z13.literal("document.read"),
+import { z as z10 } from "zod";
+var path = z10.string().min(1).max(4096);
+var requestId2 = z10.string().min(1);
+var DocumentReadSchema = z10.object({
+  type: z10.literal("document.read"),
   requestId: requestId2,
   path,
-  machineId: z13.string().optional(),
-  sessionId: z13.string().min(1).optional(),
+  machineId: z10.string().optional(),
+  sessionId: z10.string().min(1).optional(),
   basePath: path.optional()
 });
-var DocumentContentSchema = z13.object({
-  type: z13.literal("document.content"),
+var DocumentContentSchema = z10.object({
+  type: z10.literal("document.content"),
   requestId: requestId2,
   path,
-  text: z13.string(),
-  bytes: z13.number().int().nonnegative(),
-  modifiedAt: z13.string().datetime()
+  text: z10.string(),
+  bytes: z10.number().int().nonnegative(),
+  modifiedAt: z10.string().datetime()
 });
-var DocumentErrorCodeSchema = z13.enum([
+var DocumentErrorCodeSchema = z10.enum([
   "not_found",
   "not_file",
   "unsupported_path",
@@ -1014,49 +614,30 @@ var DocumentErrorCodeSchema = z13.enum([
   "session_missing",
   "read_failed"
 ]);
-var DocumentErrorSchema = z13.object({
-  type: z13.literal("document.error"),
+var DocumentErrorSchema = z10.object({
+  type: z10.literal("document.error"),
   requestId: requestId2,
   path,
   code: DocumentErrorCodeSchema
 });
 
-// ../protocol/src/routing.ts
-import { z as z14 } from "zod";
-var MachineInventorySchema = z14.object({
-  id: z14.string().min(1).max(80),
-  label: z14.string().min(1).max(120),
-  online: z14.boolean(),
-  local: z14.boolean(),
-  sessions: z14.array(z14.object({ id: z14.string(), name: z14.string(), project: z14.string(), cwd: z14.string(), topic: z14.string().optional(), state: z14.string(), readOnly: z14.boolean() })).max(500),
-  folders: z14.array(z14.object({ project: z14.string(), cwd: z14.string() })).max(100)
-});
-var RoutingContextSchema = z14.object({
-  machines: z14.array(MachineInventorySchema).min(1).max(20),
-  history: z14.array(z14.object({ question: z14.string().max(2e4), answer: z14.string().max(2e4).optional(), machineId: z14.string().optional() })).max(50)
-});
-var RouteResultSchema = z14.object({
-  /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z14.string().nullable(),
-  text: z14.string().min(1).max(2e4),
-  choices: z14.array(z14.string()).max(20).optional()
-});
+// ../protocol/src/machines.ts
+import { z as z12 } from "zod";
 
 // ../protocol/src/ssh.ts
-import { z as z15 } from "zod";
-var SshAliasSchema = z15.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 z16 } from "zod";
-var MachineIdSchema = z16.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
-var MachineSchema = z16.object({
+var MachineIdSchema = z12.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var MachineSchema = z12.object({
   id: MachineIdSchema,
-  label: z16.string().trim().min(1).max(80),
+  label: z12.string().trim().min(1).max(80),
   ssh: SshAliasSchema.optional(),
   /** Kept in the list but never connected to: no peer, no retry, no session shown until it is enabled again. */
-  disabled: z16.boolean().optional()
+  disabled: z12.boolean().optional()
 });
-var MachinesSchema = z16.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) => {
@@ -1072,53 +653,52 @@ var MachinesSchema = z16.array(MachineSchema).min(1).max(20).superRefine((list,
 });
 
 // ../protocol/src/island.ts
-import { z as z17 } from "zod";
-var IslandScaleSchema = z17.union([z17.literal("auto"), z17.literal(1), z17.literal(1.25), z17.literal(1.5), z17.literal(2)]);
-var IslandPrefsSchema = z17.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: z17.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: z17.string().trim().min(1).max(200),
-  position: z17.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: z17.boolean(),
+  discreet: z13.boolean(),
   islandScale: IslandScaleSchema,
   panelScale: IslandScaleSchema,
   /** What the island shows besides asks and questions, which it always shows. */
-  shows: z17.object({
+  shows: z13.object({
     /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
-    quick: z17.boolean(),
+    quick: z13.boolean(),
     /** The 6 s bubble when an agent finishes. */
-    finished: z17.boolean(),
+    finished: z13.boolean(),
     /** An agent's sentence in a bubble. */
-    say: z17.boolean(),
+    say: z13.boolean(),
     /** The sub-agents next to their main agent. */
-    helpers: z17.boolean()
+    helpers: z13.boolean()
   }),
   /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
-  shortcut: z17.string().trim().min(1).max(40)
+  shortcut: z13.string().trim().min(1).max(40)
 });
 
 // ../protocol/src/projects.ts
-import { z as z18 } from "zod";
-var PROJECT_COLORS = { blue: "#3b82f6", green: "#10b981", amber: "#f59e0b", violet: "#8b5cf6", teal: "#14b8a6", pink: "#ec4899", red: "#ef4444", slate: "#64748b" };
-var ProjectColorSchema = z18.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
-var ProjectIdSchema = z18.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+import { z as z14 } from "zod";
+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 = z18.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
-var RepoSchema = z18.object({ machine: MachineIdSchema, path: PathSchema });
-var ProjectSchema = z18.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: z18.string().trim().min(1).max(80),
+  name: z14.string().trim().min(1).max(80),
   color: ProjectColorSchema,
-  description: z18.string().max(500).default(""),
-  repos: z18.array(RepoSchema).max(50)
+  description: z14.string().max(500).default(""),
+  repos: z14.array(RepoSchema).max(50)
 });
-var RuleSchema = z18.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();
@@ -1144,22 +724,218 @@ ${rule.path}`;
   });
   return out;
 }
-var ProjectsSchema = z18.object({ projects: z18.array(ProjectSchema).max(100), rules: z18.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: [] };
-var under = (cwd, path2) => path2 === "/" || cwd === path2 || cwd.startsWith(`${path2}/`);
-function projectOf(session, state) {
-  const machine = session.machineId ?? "local";
-  const cwd = normalizePath(session.cwd);
-  const known = new Set(state.projects.map((p) => p.id));
-  const candidates = [
-    ...state.projects.flatMap((p) => p.repos.filter((r) => r.machine === machine).map((r) => ({ project: p.id, path: r.path, rule: false }))),
-    ...state.rules.filter((r) => r.machine === machine && known.has(r.project)).map((r) => ({ project: r.project, path: r.path, rule: true }))
-  ].filter((c) => under(cwd, c.path));
-  candidates.sort((x, y) => y.path.length - x.path.length || Number(y.rule) - Number(x.rule));
-  return candidates[0]?.project ?? null;
-}
+
+// ../protocol/src/messages.ts
+import { z as z21 } from "zod";
+
+// ../protocol/src/repos.ts
+import { z as z15 } from "zod";
+var ReposInspectSchema = z15.object({
+  type: z15.literal("repos.inspect"),
+  requestId: z15.string().min(1).max(100),
+  paths: z15.array(z15.string().min(1)).min(1).max(50),
+  machineId: z15.string().optional()
+});
+var RepoInfoSchema = z15.object({ path: z15.string(), exists: z15.boolean(), branch: z15.string().nullable() });
+var ReposInfoSchema = z15.object({ type: z15.literal("repos.info"), requestId: z15.string(), repos: z15.array(RepoInfoSchema) });
+
+// ../protocol/src/scan.ts
+import { z as z16 } from "zod";
+var ReposScanSchema = z16.object({ type: z16.literal("repos.scan"), requestId: z16.string().min(1).max(100), machineId: z16.string().optional() });
+var FoundRepoSchema = z16.object({ path: z16.string(), branch: z16.string().nullable(), remote: z16.string().optional(), manifest: z16.string().max(200).optional() });
+var ReposFoundSchema = z16.object({ type: z16.literal("repos.found"), requestId: z16.string(), repos: z16.array(FoundRepoSchema).max(500), truncated: z16.boolean(), error: z16.string().optional() });
+
+// ../protocol/src/openrig.ts
+import { z as z17 } from "zod";
+var RigNameSchema = z17.string().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a rig name");
+var RigSeatNameSchema = z17.string().min(3).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a seat");
+var SeatPermissionsSchema = z17.enum(["inherit", "floor", "auto", "full_bypass"]);
+var RigSeatSchema = z17.object({
+  logicalId: z17.string(),
+  session: z17.string(),
+  runtime: z17.string(),
+  model: z17.string().nullable(),
+  sessionStatus: z17.string(),
+  lifecycleState: z17.string(),
+  activity: z17.string(),
+  stopped: z17.boolean(),
+  work: z17.number().int().min(0)
+});
+var RigSchema = z17.object({
+  id: z17.string(),
+  name: z17.string(),
+  status: z17.string(),
+  lifecycleState: z17.string(),
+  seats: z17.number().int().min(0),
+  running: z17.number().int().min(0),
+  attention: z17.number().int().min(0),
+  uptime: z17.string().nullable(),
+  snapshot: z17.string().nullable(),
+  nodes: z17.array(RigSeatSchema)
+});
+var RigDaemonStateSchema = z17.enum(["running", "stopped", "stale", "unknown"]);
+var RigKernelStateSchema = z17.enum(["ready", "starting", "stopped", "skipped", "absent", "unknown"]);
+var OpenRigStateSchema = z17.object({
+  installed: z17.boolean(),
+  version: z17.string().optional(),
+  daemon: z17.object({ state: RigDaemonStateSchema, pid: z17.number().int().optional(), port: z17.number().int().optional(), message: z17.string().optional() }),
+  kernel: z17.object({ state: RigKernelStateSchema }),
+  rigs: z17.array(RigSchema),
+  /** When it was read (ISO). */
+  at: z17.string()
+});
+var OpenRigActionSchema = z17.discriminatedUnion("kind", [
+  /** `restore` `last`: `rig start --last` (the rigs that were running come back); `none`: `rig daemon start`. */
+  z17.object({ kind: z17.literal("daemon.start"), restore: z17.enum(["last", "none"]).optional(), noKernel: z17.boolean().optional() }),
+  z17.object({ kind: z17.literal("daemon.stop") }),
+  z17.object({ kind: z17.literal("daemon.restart"), restore: z17.enum(["last", "none"]).optional() }),
+  z17.object({ kind: z17.literal("kernel.start") }),
+  z17.object({ kind: z17.literal("kernel.stop") }),
+  z17.object({ kind: z17.literal("kernel.restart") }),
+  z17.object({ kind: z17.literal("rig.start"), rig: RigNameSchema }),
+  z17.object({ kind: z17.literal("rig.stop"), rig: RigNameSchema, snapshot: z17.boolean().optional(), force: z17.boolean().optional(), delete: z17.boolean().optional() }),
+  z17.object({ kind: z17.literal("rig.restart"), rig: RigNameSchema }),
+  /** A seat's settings (docs/mockups/ledge-openrig-groups.html, view 2). `runtime`: moves it now to the other harness (a successor
+   *  takes its context, `rig seat set-runtime`), `model` and `effort` going with it; without it, `model`, `effort` and `permissions`
+   *  apply at its next resume. `dryRun`: the move's plan only. */
+  z17.object({
+    kind: z17.literal("seat.set"),
+    seat: RigSeatNameSchema,
+    runtime: z17.enum(["claude-code", "codex"]).optional(),
+    model: ModelIdSchema.optional(),
+    effort: EffortSchema.optional(),
+    permissions: SeatPermissionsSchema.optional(),
+    dryRun: z17.boolean().optional()
+  })
+]);
+var OpenRigStatusSchema = z17.object({ type: z17.literal("openrig.status"), requestId: z17.string().min(1).max(100), machineId: z17.string().optional() });
+var OpenRigActSchema = z17.object({ type: z17.literal("openrig.act"), requestId: z17.string().min(1).max(100), action: OpenRigActionSchema, machineId: z17.string().optional() });
+var OpenRigUnreachableSchema = z17.enum(["offline", "outdated"]);
+var OpenRigStateMessageSchema = z17.object({
+  type: z17.literal("openrig.state"),
+  requestId: z17.string().optional(),
+  machineId: z17.string().optional(),
+  state: OpenRigStateSchema.optional(),
+  error: OpenRigUnreachableSchema.optional()
+});
+var OpenRigDoneSchema = z17.object({
+  type: z17.literal("openrig.done"),
+  requestId: z17.string(),
+  machineId: z17.string().optional(),
+  ok: z17.boolean(),
+  commands: z17.array(z17.string()),
+  output: z17.string().optional(),
+  error: z17.string().optional()
+});
+var RigSpecMemberSchema = z17.object({
+  id: z17.string(),
+  runtime: z17.string(),
+  model: z17.string().optional(),
+  agent: z17.string(),
+  /** Its `permission_policy`, as written. */
+  policy: z17.string().optional()
+});
+var RigSpecPodSchema = z17.object({ id: z17.string(), label: z17.string().optional(), members: z17.array(RigSpecMemberSchema) });
+var RigSpecSchema = z17.object({
+  name: z17.string(),
+  source: z17.string(),
+  summary: z17.string().optional(),
+  path: z17.string(),
+  /** The rig's `permission_policy`, as written (`builtin:auto`, a file…). */
+  policy: z17.string().optional(),
+  pods: z17.array(RigSpecPodSchema),
+  edges: z17.number().int().min(0)
+});
+var OpenRigSpecsSchema = z17.object({ type: z17.literal("openrig.specs"), requestId: z17.string().min(1).max(100), machineId: z17.string().optional() });
+var OpenRigSpecListSchema = z17.object({
+  type: z17.literal("openrig.specList"),
+  requestId: z17.string(),
+  machineId: z17.string().optional(),
+  specs: z17.array(RigSpecSchema),
+  error: z17.string().optional()
+});
+var RigRoleSchema = z17.string().min(3).max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*\.[A-Za-z0-9][A-Za-z0-9_-]*$/, "not a role");
+var RuntimeSchema = z17.enum(["claude-code", "codex"]);
+var RigPolicySchema = z17.enum(["auto", "standard", "open", "yolo", "locked"]);
+var RIG_POLICIES = RigPolicySchema.options;
+var RigLaunchSchema = z17.object({
+  spec: RigNameSchema,
+  cwd: z17.string().min(1).max(4096),
+  name: RigNameSchema,
+  seats: z17.record(RigRoleSchema, z17.number().int().min(0).max(9)).optional(),
+  runtimes: z17.record(RigRoleSchema, RuntimeSchema).optional(),
+  models: z17.record(RigRoleSchema, z17.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/)).optional(),
+  delegation: z17.enum(["pairs", "all"]).optional(),
+  save: z17.boolean().optional(),
+  plan: z17.boolean().optional(),
+  /** The rig's permission policy, in place of the spec's; `policies`: a role's, over the rig's. */
+  policy: RigPolicySchema.optional(),
+  policies: z17.record(RigRoleSchema, RigPolicySchema).optional(),
+  /** Accept the harnesses' first-launch warnings (`rig up --non-interruptive`), so a bypassing seat does not stop on Claude's dialog. */
+  nonInterruptive: z17.boolean().optional()
+});
+var OpenRigLaunchSchema = z17.object({ type: z17.literal("openrig.launch"), requestId: z17.string().min(1).max(100), launch: RigLaunchSchema, machineId: z17.string().optional() });
+var OpenRigLaunchedSchema = z17.object({
+  type: z17.literal("openrig.launched"),
+  requestId: z17.string(),
+  machineId: z17.string().optional(),
+  ok: z17.boolean(),
+  plan: z17.boolean(),
+  commands: z17.array(z17.string()),
+  yaml: z17.string().optional(),
+  seats: z17.number().int().optional(),
+  output: z17.string().optional(),
+  error: z17.string().optional(),
+  /** What `rig up --plan` concluded: its status (`planned`…), its errors and its warnings (one per seat without a permission policy…). */
+  check: z17.object({ status: z17.string(), errors: z17.array(z17.string()), warnings: z17.array(z17.string()) }).optional()
+});
+var OpenRigSeatsSchema = z17.object({
+  type: z17.literal("openrig.seats"),
+  requestId: z17.string().min(1).max(100),
+  machineId: z17.string().optional(),
+  rig: RigNameSchema,
+  seats: z17.record(RigRoleSchema, z17.number().int().min(0).max(9)),
+  /** How the added seats are linked, where OpenRig can add links to a running rig (0.7+): like a launch's. */
+  delegation: z17.enum(["pairs", "all"]).optional()
+});
+var OpenRigReseatedSchema = z17.object({
+  type: z17.literal("openrig.reseated"),
+  requestId: z17.string(),
+  machineId: z17.string().optional(),
+  ok: z17.boolean(),
+  commands: z17.array(z17.string()),
+  added: z17.array(z17.string()),
+  removed: z17.array(z17.string()),
+  output: z17.string().optional(),
+  error: z17.string().optional(),
+  /** The links ensured between the seats; `linksUnsupported`: this OpenRig cannot add links to a running rig (before 0.7). */
+  links: z17.number().int().optional(),
+  linksUnsupported: z17.boolean().optional()
+});
+
+// ../protocol/src/routing.ts
+import { z as z18 } from "zod";
+var MachineInventorySchema = z18.object({
+  id: z18.string().min(1).max(80),
+  label: z18.string().min(1).max(120),
+  online: z18.boolean(),
+  local: z18.boolean(),
+  sessions: z18.array(z18.object({ id: z18.string(), name: z18.string(), project: z18.string(), cwd: z18.string(), topic: z18.string().optional(), state: z18.string(), readOnly: z18.boolean() })).max(500),
+  folders: z18.array(z18.object({ project: z18.string(), cwd: z18.string() })).max(100)
+});
+var RoutingContextSchema = z18.object({
+  machines: z18.array(MachineInventorySchema).min(1).max(20),
+  history: z18.array(z18.object({ question: z18.string().max(2e4), answer: z18.string().max(2e4).optional(), machineId: z18.string().optional() })).max(50)
+});
+var RouteResultSchema = z18.object({
+  /** Null means an answer or a clarification, never an implicit local destination. */
+  machineId: z18.string().nullable(),
+  text: z18.string().min(1).max(2e4),
+  choices: z18.array(z18.string()).max(20).optional()
+});
 
 // ../protocol/src/thread.ts
 import { z as z19 } from "zod";
@@ -1171,7 +947,22 @@ var ThreadItemSchema = z19.discriminatedUnion("kind", [
   z19.object({ kind: z19.literal("message"), ...base, text: z19.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. */
-  z19.object({ kind: z19.literal("tool"), ...base, tool: z19.string(), label: z19.string(), input: z19.string().optional(), output: z19.string().optional(), error: z19.string().optional(), status: ToolStatusSchema, durationMs: z19.number().nonnegative().optional(), files: z19.array(FileChangeSchema).default([]), byClose: z19.literal(true).optional() }),
+  z19.object({
+    kind: z19.literal("tool"),
+    ...base,
+    tool: z19.string(),
+    label: z19.string(),
+    input: z19.string().optional(),
+    output: z19.string().optional(),
+    error: z19.string().optional(),
+    status: ToolStatusSchema,
+    durationMs: z19.number().nonnegative().optional(),
+    files: z19.array(FileChangeSchema).default([]),
+    byClose: z19.literal(true).optional(),
+    /** Images the tool returned (a browser screenshot), in order; `imagesDropped`: some were not kept. */
+    images: z19.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional(),
+    imagesDropped: z19.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. */
   z19.object({ kind: z19.literal("permission"), ...base, tool: z19.string(), text: z19.string(), decision: z19.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z19.literal(true).optional() }),
@@ -1207,7 +998,6 @@ var ThreadItemSchema = z19.discriminatedUnion("kind", [
 
 // ../protocol/src/mobile.ts
 import { z as z20 } from "zod";
-var DEFAULT_RELAY_URL = "https://app.kl-ledge.dev";
 var RelayUrlSchema = z20.string().transform((v, ctx) => {
   const bad = () => {
     ctx.addIssue({ code: z20.ZodIssueCode.custom, message: "invalid relay URL" });
@@ -1254,7 +1044,6 @@ var MobileStateSchema = z20.object({
 });
 
 // ../protocol/src/messages.ts
-var PROTOCOL_PORT = 47831;
 var RefusalCodeSchema = z21.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 = z21.object({
   name: z21.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
@@ -1274,8 +1063,10 @@ var SessionEventSchema = z21.object({
   task: z21.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
   interrupt: z21.boolean().optional(),
-  /** UserPromptSubmit: the images the prompt carried, by attachment id. */
+  /** UserPromptSubmit, PostToolUse: the images the prompt or the tool result carried, by attachment id. */
   attachments: z21.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+  /** PostToolUse: some of the result's images were not kept. */
+  imagesDropped: z21.boolean().optional(),
   /** QueueUpdate: OMP's queue as it stands. */
   queue: z21.array(z21.object({ text: z21.string(), mode: z21.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. */
@@ -1437,6 +1228,7 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   z21.object({ type: z21.literal("chat.route"), qid: z21.string().min(1).max(100), text: z21.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
   AttachmentPutSchema,
+  AttachmentCaptureSchema,
   AttachmentGetSchema,
   ReposInspectSchema,
   ReposScanSchema,
@@ -1601,106 +1393,6 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   HandoverBriefSchema,
   HandoverShowSchema
 ]);
-function parseClientMessage(raw) {
-  return ClientMessageSchema.parse(raw);
-}
-function parseServerMessage(raw) {
-  return ServerMessageSchema.parse(raw);
-}
-
-// ../protocol/src/names.ts
-var NAMES = [
-  "Otto",
-  "Pim",
-  "Nova",
-  "Bix",
-  "Lu",
-  "Max",
-  "Ida",
-  "Rex",
-  "Zoe",
-  "Kit",
-  "Ari",
-  "Bo",
-  "Cal",
-  "Dee",
-  "Eli",
-  "Fay",
-  "Gus",
-  "Hal",
-  "Ivy",
-  "Jax",
-  "Kai",
-  "Lio",
-  "Mo",
-  "Nia",
-  "Oz",
-  "Pax",
-  "Quin",
-  "Rae",
-  "Sol",
-  "Tad",
-  "Uma",
-  "Vic",
-  "Wyn",
-  "Xen",
-  "Yan",
-  "Zia",
-  "Abe",
-  "Bea",
-  "Cy",
-  "Dot",
-  "Eva",
-  "Fin",
-  "Gil",
-  "Hen",
-  "Iro",
-  "Jo",
-  "Kip",
-  "Lex",
-  "Mia",
-  "Ned",
-  "Ola",
-  "Pat",
-  "Rio",
-  "Sam",
-  "Tia",
-  "Ulf",
-  "Val",
-  "Wes",
-  "Yui",
-  "Zed",
-  "Ash",
-  "Bry",
-  "Cleo",
-  "Dax"
-];
-var cap = (s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
-function pickName(taken, preferred) {
-  const used = new Set(taken);
-  const free = (n) => !used.has(n);
-  const wanted = preferred?.trim();
-  if (wanted) {
-    const base2 = cap(wanted);
-    if (free(base2)) return base2;
-    for (let i = 2; ; i++) if (free(`${base2}-${i}`)) return `${base2}-${i}`;
-  }
-  const first = NAMES.find(free);
-  if (first) return first;
-  for (let i = 2; ; i++) if (free(`${NAMES[0]}-${i}`)) return `${NAMES[0]}-${i}`;
-}
-var namesInUse = (sessions) => [...sessions].filter((s) => s.state !== "exited" && !s.archivedAt).map((s) => s.name);
-
-// ../protocol/src/topic.ts
-var TOPIC_MAX = 80;
-function cleanTopic(text2) {
-  const line = text2.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0) ?? "";
-  const flat = line.replace(/\s+/g, " ");
-  return flat.length > TOPIC_MAX ? `${flat.slice(0, TOPIC_MAX - 1).trimEnd()}\u2026` : flat;
-}
-function sessionTitle(s) {
-  return `${s.name} \xB7 ${s.topic || s.project}`;
-}
 
 // ../protocol/src/relay.ts
 import { z as z22 } from "zod";
@@ -1746,7 +1438,6 @@ var SealedFrameSchema = z22.discriminatedUnion("k", [
 
 // ../protocol/src/relayAuth.ts
 import { z as z23 } from "zod";
-var RELAY_CLOSE_SIGNED_OUT = 4001;
 var DeviceStartResponseSchema = z23.object({
   deviceCode: z23.string().min(1),
   userCode: z23.string().min(1),
@@ -1820,18 +1511,7 @@ var PushPayloadSchema = z24.object({
 
 // ../protocol/src/phone.ts
 var PHONE_PROTOCOL = 1;
-var PAD_TIERS = [1024, 4096, 16384, 65536, 262144, 655360];
-var PLAIN_MAX = 655360;
 var utf8 = new TextEncoder();
-function padPlain(json) {
-  const bytes = utf8.encode(json).length;
-  if (bytes > PLAIN_MAX) return null;
-  const tier = PAD_TIERS.find((t) => t >= bytes);
-  if (tier === void 0) return null;
-  return json + " ".repeat(tier - bytes);
-}
-var THREAD_ITEMS_MAX = 200;
-var THREAD_BUDGET = 524288;
 var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var CHECKLIST_TASKS_MAX = 50;
@@ -1849,8 +1529,6 @@ var PhoneChecklistSummarySchema = z25.object({
   current: z25.string().max(CHECKLIST_TEXT_MAX).optional(),
   cut: z25.literal(true).optional()
 });
-var PENDING_BODY_MAX = 65536;
-var SNAPSHOT_BODY_MAX = 2048;
 var RiskSchema = z25.enum(["low", "high"]);
 var RiskReasonSchema = z25.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 = z25.string().uuid();
@@ -1864,7 +1542,6 @@ var CapabilitiesSchema = z25.object({
   /** OMP's dialog questions can be answered from the phone; absent = false. */
   questions: z25.boolean().optional()
 });
-var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
 var CapabilitiesByToolSchema = z25.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
 var PhonePendingSchema = PendingSchema.extend({ key: z25.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z25.literal(true).optional() });
 var SwitchableSessionSchema = SessionSchema.extend({ canSwitch: z25.literal(true).optional() });
@@ -2002,13 +1679,11 @@ var PhoneChatTurnSchema = z25.object({
   ignoredAt: z25.string().datetime().optional(),
   attachments: z25.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
 }).strict();
-var CHAT_HISTORY_BUDGET = 393216;
 var sessionId = z25.string().min(1).max(100);
 var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z25.string().min(1).max(64) });
 var CardRowsSchema = z25.array(z25.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 pcOp = { op: OperationIdSchema, assertion: AssertionSchema.optional() };
 var PcActionSchema = z25.enum(["update", "restart"]);
-var pcSubject = (action, version) => action === "update" ? `update@${version ?? ""}` : "restart";
 var PhoneClientMessageSchema = z25.discriminatedUnion("type", [
   z25.object({ type: z25.literal("snapshot.request") }),
   z25.object({ type: z25.literal("session.thread"), id: sessionId }),
@@ -2181,296 +1856,182 @@ var PhoneServerMessageSchema = z25.discriminatedUnion("type", [
   z25.object({ type: z25.literal("error"), code: z25.enum(["invalid", "unknown_session", "too_large"]), request: z25.string().max(40).optional() })
 ]);
 
-// ../protocol/src/todos.ts
-var TODO_TOOLS = /* @__PURE__ */ new Set(["TodoWrite", "update_plan", "todo"]);
-var STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
-var statusOf = (s) => typeof s === "string" && STATUSES.has(s) ? s : "pending";
-var text = (s) => typeof s === "string" && s.trim() !== "" ? s : null;
-var record = (v) => v && typeof v === "object" ? v : {};
-function omp(input) {
-  if (!Array.isArray(input.phases)) return void 0;
-  const phases = input.phases.map(record);
-  const out = [];
-  for (const ph of phases) {
-    for (const raw of Array.isArray(ph.tasks) ? ph.tasks : []) {
-      const e = record(raw);
-      const said = text(e.content);
-      if (said === null) continue;
-      const blocked = e.status === "blocked";
-      const name = phases.length > 1 ? text(ph.name) : null;
-      out.push({ text: `${name ? `${name} \xB7 ` : ""}${said}${blocked && text(e.blocker) ? ` (blocked: ${e.blocker})` : ""}`, status: blocked ? "pending" : statusOf(e.status) });
+// src/imageInfo.ts
+var ok = (mime, width, height) => width > 0 && height > 0 ? { mime, width, height } : null;
+function jpeg(b) {
+  let i = 2;
+  while (i + 4 <= b.length) {
+    if (b[i] !== 255) {
+      i++;
+      continue;
     }
+    const m = b[i + 1];
+    if (m === 255) {
+      i++;
+      continue;
+    }
+    if (m === 216 || m === 1 || m >= 208 && m <= 215) {
+      i += 2;
+      continue;
+    }
+    const len = b.readUInt16BE(i + 2);
+    if (m >= 192 && m <= 207 && m !== 196 && m !== 200 && m !== 204) return i + 9 <= b.length ? ok("image/jpeg", b.readUInt16BE(i + 7), b.readUInt16BE(i + 5)) : null;
+    i += 2 + len;
   }
-  return out;
+  return null;
 }
-function listOf(t) {
-  if (!TODO_TOOLS.has(t.tool) || t.input === void 0) return void 0;
-  let input;
-  try {
-    input = record(JSON.parse(t.input));
-  } catch {
-    return void 0;
+function webp(b) {
+  const kind = b.toString("latin1", 12, 16);
+  if (kind === "VP8X") return b.length >= 30 ? ok("image/webp", b.readUIntLE(24, 3) + 1, b.readUIntLE(27, 3) + 1) : null;
+  if (kind === "VP8L") {
+    if (b.length < 25 || b[20] !== 47) return null;
+    const bits = b.readUInt32LE(21);
+    return ok("image/webp", (bits & 16383) + 1, (bits >>> 14 & 16383) + 1);
   }
-  if (t.tool === "todo") return omp(input);
-  const claude = t.tool === "TodoWrite";
-  const list = claude ? input.todos : input.plan;
-  if (!Array.isArray(list)) return void 0;
-  const out = [];
-  for (const raw of list) {
-    const e = record(raw);
-    const status = statusOf(e.status);
-    const said = claude ? status === "in_progress" ? text(e.activeForm) ?? text(e.content) : text(e.content) : text(e.step);
-    if (said !== null) out.push({ text: said, status });
-  }
-  return out;
+  if (kind === "VP8 ") return b.length >= 30 && b[23] === 157 && b[24] === 1 && b[25] === 42 ? ok("image/webp", b.readUInt16LE(26) & 16383, b.readUInt16LE(28) & 16383) : null;
+  return null;
 }
-function latestTodos(items, helperId) {
-  for (let i = items.length - 1; i >= 0; i--) {
-    const it = items[i];
-    if (it.kind !== "tool" || it.helperId !== helperId || !TODO_TOOLS.has(it.tool)) continue;
-    const list = listOf(it);
-    if (list) return list.length > 0 ? list : null;
+function imageInfo(b) {
+  try {
+    if (b.length >= 24 && b.readUInt32BE(0) === 2303741511 && b.readUInt32BE(4) === 218765834 && b.toString("latin1", 12, 16) === "IHDR") return ok("image/png", b.readUInt32BE(16), b.readUInt32BE(20));
+    if (b.length >= 10 && (b.toString("latin1", 0, 6) === "GIF87a" || b.toString("latin1", 0, 6) === "GIF89a")) return ok("image/gif", b.readUInt16LE(6), b.readUInt16LE(8));
+    if (b.length >= 4 && b[0] === 255 && b[1] === 216) return jpeg(b);
+    if (b.length >= 16 && b.toString("latin1", 0, 4) === "RIFF" && b.toString("latin1", 8, 12) === "WEBP") return webp(b);
+  } catch {
   }
   return null;
 }
-var doneCount = (todos) => todos.filter((x) => x.status === "completed").length;
 
-// src/auth.ts
-import { createHash, createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmod, link, mkdir, readFile, unlink, writeFile } from "fs/promises";
-import { readFileSync } from "fs";
-import { dirname } from "path";
-var TOKEN_RE = /^[0-9a-f]{64}$/;
-var DAEMON_PROTOCOL_PREFIX = "ledge.";
-function isDaemonToken(value) {
-  return TOKEN_RE.test(value);
-}
-function tokenEquals(presented, expected) {
-  const a = createHash("sha256").update(presented.slice(0, 256), "utf8").digest();
-  const b = createHash("sha256").update(expected, "utf8").digest();
-  return timingSafeEqual(a, b);
-}
-function hostAllowed(hostHeader) {
-  const raw = Array.isArray(hostHeader) ? hostHeader[0] : hostHeader;
-  if (!raw || raw.length > 255) return false;
-  const host = raw.trim().toLowerCase();
-  if (!host || host.includes(" ") || host.endsWith(".")) return false;
-  let name;
-  if (host.startsWith("[")) {
-    const end = host.indexOf("]");
-    if (end < 0) return false;
-    name = host.slice(1, end);
-    const rest = host.slice(end + 1);
-    if (rest !== "" && !/^:\d{1,5}$/.test(rest)) return false;
-  } else {
-    const colon = host.lastIndexOf(":");
-    if (colon >= 0) {
-      if (!/^\d{1,5}$/.test(host.slice(colon + 1))) return false;
-      name = host.slice(0, colon);
-    } else name = host;
+// src/daemon/attachments.ts
+var AttachmentError = class extends Error {
+  constructor(reason) {
+    super(`attachment: ${reason}`);
+    this.reason = reason;
+    this.name = "AttachmentError";
   }
-  return name === "localhost" || name === "127.0.0.1" || name === "::1";
-}
-function headerValue(value, max) {
-  const raw = Array.isArray(value) ? value.join(",") : value;
-  return !raw || raw.length > max ? "" : raw;
-}
-function bearerToken(authorization) {
-  if (!authorization || authorization.length > 512) return "";
-  return /^Bearer[ \t]+(\S+)$/i.exec(authorization)?.[1] ?? "";
-}
-function protocolToken(header) {
-  const raw = headerValue(header, 512);
-  if (!raw) return "";
-  for (const part of raw.split(",").slice(0, 8)) {
-    const protocol = part.trim();
-    if (protocol.startsWith(DAEMON_PROTOCOL_PREFIX)) return protocol.slice(DAEMON_PROTOCOL_PREFIX.length);
+  reason;
+};
+var MAX_AGE_MS = 24 * 36e5;
+
+// src/daemon/reduce.ts
+import { decode, encode } from "jpeg-js";
+import { PNG } from "pngjs";
+var DECODE_MAX_PIXELS = 2e7;
+var MIN_SIDE = 16;
+function flattenOnWhite(data) {
+  for (let i = 0; i < data.length; i += 4) {
+    const a = data[i + 3];
+    if (a === 255) continue;
+    for (let c = 0; c < 3; c++) data[i + c] = Math.round((data[i + c] * a + 255 * (255 - a)) / 255);
+    data[i + 3] = 255;
   }
-  return "";
+  return data;
 }
-function requestAuthorized(headers, expected) {
-  const bearerOk = tokenEquals(bearerToken(typeof headers.authorization === "string" ? headers.authorization : void 0), expected);
-  const presented = protocolToken(headers["sec-websocket-protocol"]);
-  return bearerOk || presented !== "" && tokenEquals(presented, expected);
-}
-function selectDaemonProtocol(protocols, expected) {
-  for (const protocol of protocols) {
-    if (protocol.startsWith(DAEMON_PROTOCOL_PREFIX) && tokenEquals(protocol.slice(DAEMON_PROTOCOL_PREFIX.length), expected)) return protocol;
+function decodeRaster(raw, mime) {
+  try {
+    if (mime === "image/png") {
+      const p = PNG.sync.read(raw);
+      return { width: p.width, height: p.height, data: flattenOnWhite(p.data) };
+    }
+    const j = decode(raw, { useTArray: true, formatAsRGBA: true });
+    return { width: j.width, height: j.height, data: j.data };
+  } catch {
+    throw new AttachmentError("not_image");
   }
-  return false;
 }
-async function readTokenFile(file) {
-  try {
-    const raw = (await readFile(file, "utf8")).trim();
-    return isDaemonToken(raw) ? raw : void 0;
-  } catch (e) {
-    if (e.code === "ENOENT") return void 0;
-    throw e;
+function resize(src, width, height) {
+  const { width: sw, height: sh, data } = src;
+  const sx = sw / width, sy = sh / height;
+  const out = Buffer.alloc(width * height * 4, 255);
+  const rowCache = /* @__PURE__ */ new Map();
+  const reduceRow = (y) => {
+    const cached = rowCache.get(y);
+    if (cached) return cached;
+    const row = new Float32Array(width * 3);
+    for (let ox = 0; ox < width; ox++) {
+      const x0 = ox * sx, x1 = (ox + 1) * sx;
+      let r = 0, g = 0, b = 0;
+      for (let x = Math.floor(x0); x < Math.min(sw, Math.ceil(x1)); x++) {
+        const w = Math.min(x + 1, x1) - Math.max(x, x0);
+        const i = (y * sw + x) * 4;
+        r += w * data[i];
+        g += w * data[i + 1];
+        b += w * data[i + 2];
+      }
+      row[ox * 3] = r / sx;
+      row[ox * 3 + 1] = g / sx;
+      row[ox * 3 + 2] = b / sx;
+    }
+    rowCache.set(y, row);
+    return row;
+  };
+  for (let oy = 0; oy < height; oy++) {
+    const y0 = oy * sy, y1 = (oy + 1) * sy;
+    const acc = new Float32Array(width * 3);
+    for (let y = Math.floor(y0); y < Math.min(sh, Math.ceil(y1)); y++) {
+      const w = Math.min(y + 1, y1) - Math.max(y, y0);
+      const row = reduceRow(y);
+      for (let k = 0; k < acc.length; k++) acc[k] += w * row[k];
+    }
+    for (let ox = 0; ox < width; ox++) {
+      const o = (oy * width + ox) * 4;
+      out[o] = Math.round(acc[ox * 3] / sy);
+      out[o + 1] = Math.round(acc[ox * 3 + 1] / sy);
+      out[o + 2] = Math.round(acc[ox * 3 + 2] / sy);
+    }
+    for (const k of rowCache.keys()) if (k < Math.floor(y1) - 1) rowCache.delete(k);
   }
+  return { width, height, data: out };
 }
-async function lockTokenFile(file) {
-  await chmod(file, 384);
+var qualityShare = (q, from) => 1 - (from - q) * 0.0115;
+function toJpeg(src, long, max, from, floor) {
+  const srcLong = Math.max(src.width, src.height);
+  const encodeAt = (side2, q2) => {
+    if (side2 < MIN_SIDE) throw new AttachmentError("too_large");
+    const scale = side2 / srcLong;
+    const r = scale < 1 ? resize(src, Math.max(1, Math.round(src.width * scale)), Math.max(1, Math.round(src.height * scale))) : src;
+    return encode({ data: r.data, width: r.width, height: r.height }, q2).data;
+  };
+  let side = Math.min(long, srcLong);
+  let jpg = encodeAt(side, from);
+  if (jpg.length <= max) return jpg;
+  const ratio = max * 0.85 / jpg.length;
+  let q = from;
+  while (q > floor && qualityShare(q, from) > ratio) q = Math.max(floor, q - 5);
+  if (qualityShare(q, from) > ratio) side = Math.floor(side * Math.sqrt(ratio / qualityShare(q, from)));
+  jpg = encodeAt(side, q);
+  if (jpg.length <= max) return jpg;
+  jpg = encodeAt(Math.floor(side * Math.sqrt(max * 0.7 / jpg.length)), floor);
+  if (jpg.length <= max) return jpg;
+  throw new AttachmentError("too_large");
 }
-async function ensureDaemonToken() {
-  const file = paths().token;
-  await mkdir(dirname(file), { recursive: true });
-  const current = await readTokenFile(file);
-  if (current) {
-    await lockTokenFile(file);
-    return current;
+function reduceCapture(raw) {
+  if (raw.length > CAPTURE_RAW_MAX) throw new AttachmentError("too_large");
+  const info = imageInfo(raw);
+  if (!info) throw new AttachmentError("not_image");
+  const within = Math.max(info.width, info.height) <= IMAGE_LONG_SIDE && raw.length <= ATTACHMENT_MAX;
+  if (info.mime === "image/webp" || info.mime === "image/gif") {
+    if (!within) throw new AttachmentError("too_large");
+    return { image: raw };
   }
-  const token = randomBytes(32).toString("hex");
-  const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-  await writeFile(tmp, `${token}
-`, { mode: 384, flag: "wx" });
-  await chmod(tmp, 384);
+  if (info.width * info.height > DECODE_MAX_PIXELS) throw new AttachmentError("too_large");
+  let src;
   try {
-    await link(tmp, file);
+    src = decodeRaster(raw, info.mime);
   } catch (e) {
-    await unlink(tmp).catch(() => {
-    });
-    if (e.code !== "EEXIST") throw e;
-    const raced = await readTokenFile(file);
-    if (raced) {
-      await lockTokenFile(file);
-      return raced;
-    }
-    await writeFile(file, `${token}
-`, { mode: 384 });
+    if (within) return { image: raw };
+    throw e;
   }
-  await unlink(tmp).catch(() => {
-  });
-  await lockTokenFile(file);
-  const stored = await readTokenFile(file);
-  if (!stored) throw new Error("daemon token was not stored");
-  return stored;
-}
-var SESSION_KEY_VAR = "LEDGE_SESSION_KEY";
-function sessionKey(id, token = readDaemonToken()) {
-  return token ? createHmac("sha256", token).update(`ledge-session:${id}`).digest("hex") : void 0;
+  const image = within ? raw : toJpeg(src, IMAGE_LONG_SIDE, ATTACHMENT_MAX, 85, 45);
+  return { image, preview: toJpeg(src, PREVIEW_LONG_SIDE, PREVIEW_MAX, 70, 40) };
 }
-function readDaemonToken() {
+
+// src/daemon/reduceWorker.ts
+parentPort.on("message", (raw) => {
   try {
-    const raw = readFileSync(paths().token, "utf8").trim();
-    return isDaemonToken(raw) ? raw : void 0;
-  } catch {
-    return void 0;
+    parentPort.postMessage(reduceCapture(Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength)));
+  } catch (e) {
+    if (!(e instanceof AttachmentError)) throw e;
+    parentPort.postMessage({ reason: e.reason });
   }
-}
-
-export {
-  ATTACHMENT_ID,
-  ATTACHMENT_MAX,
-  ATTACHMENT_LOCAL_MAX,
-  PREVIEW_MAX,
-  ATTACHMENTS_MAX,
-  AttachmentRefSchema,
-  CONTEXT_NEAR,
-  CONTEXT_NEAR_MIN,
-  CONTEXT_NEAR_MAX,
-  ContextPrefsSchema,
-  contextNear,
-  BRIEF_MAX,
-  ToolSchema,
-  SessionSchema,
-  backendOf,
-  isArchived,
-  ModelIdSchema,
-  EffortSchema,
-  ModelRefusalSchema,
-  extractProposal,
-  parseRelayBlock,
-  parseCloseBlock,
-  parseTaskBlock,
-  parseProjectBlock,
-  NOTE_MAX,
-  NOTE_NOT_TYPED,
-  offers,
-  pendingKey,
-  TASK_TITLE_MAX,
-  TASK_TEXT_MAX,
-  LEDGE_GIVER,
-  transmissions,
-  givenByLedge,
-  taskClosed,
-  openDecision,
-  ACTIONS,
-  actionById,
-  riskOf,
-  LEGACY_FENCE_ACTION,
-  parseActionBlock,
-  NEVER_PROPOSED,
-  MAX_PROPOSALS,
-  DETAIL_MAX,
-  ACTION_ERROR_CODES,
-  ChatTurnSchema,
-  proposalRows,
-  DOCUMENT_MAX_BYTES,
-  SshAliasSchema,
-  MachinesSchema,
-  IslandPrefsSchema,
-  PROJECT_COLORS,
-  ProjectsSchema,
-  DEFAULT_PROJECTS,
-  projectOf,
-  RigSeatNameSchema,
-  KERNEL_RIG,
-  rigCommands,
-  showRigCommand,
-  RIG_POLICIES,
-  seatsByRole,
-  seatPlan,
-  RouteResultSchema,
-  DEFAULT_RELAY_URL,
-  MobileConfigSchema,
-  PROTOCOL_PORT,
-  RefusalCodeSchema,
-  RecentSchema,
-  SEMVER,
-  MESSAGE_MAX,
-  SUMMARY_MAX,
-  parseClientMessage,
-  parseServerMessage,
-  NAMES,
-  pickName,
-  namesInUse,
-  TOPIC_MAX,
-  cleanTopic,
-  sessionTitle,
-  RelayServerMessageSchema,
-  PAIR_LABEL_MAX,
-  SealedFrameSchema,
-  RELAY_CLOSE_SIGNED_OUT,
-  DeviceStartResponseSchema,
-  DevicePollResponseSchema,
-  pushEndpointAllowed,
-  PushSendResultSchema,
-  PushPayloadSchema,
-  PHONE_PROTOCOL,
-  padPlain,
-  THREAD_ITEMS_MAX,
-  THREAD_BUDGET,
-  THREAD_TEXT_MAX,
-  TOOL_TEXT_MAX,
-  CHECKLIST_TASKS_MAX,
-  CHECKLIST_TEXT_MAX,
-  PENDING_BODY_MAX,
-  SNAPSHOT_BODY_MAX,
-  OperationIdSchema,
-  UNTYPABLE,
-  CHAT_HISTORY_BUDGET,
-  pcSubject,
-  PhoneClientMessageSchema,
-  PhoneModelChoiceSchema,
-  TODO_TOOLS,
-  latestTodos,
-  doneCount,
-  tokenEquals,
-  hostAllowed,
-  requestAuthorized,
-  selectDaemonProtocol,
-  ensureDaemonToken,
-  SESSION_KEY_VAR,
-  sessionKey,
-  readDaemonToken
-};
+});