@paradow/ledge 0.16.1 → 0.17.0

package/dist/cli/{chunk-Q5WWH7FG.js → chunk-QD27W6W5.js}

@@ -1,6 +1,125 @@
 import {
   paths
-} from "./chunk-R5462SQM.js";
+} from "./chunk-ELLXOV4Q.js";
+
+// src/auth.ts
+import { createHash, 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;
+  }
+  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);
+  }
+  return "";
+}
+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;
+  }
+  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;
+  }
+}
+async function lockTokenFile(file) {
+  await chmod(file, 384);
+}
+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;
+  }
+  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);
+  try {
+    await link(tmp, file);
+  } 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 });
+  }
+  await unlink(tmp).catch(() => {
+  });
+  await lockTokenFile(file);
+  const stored = await readTokenFile(file);
+  if (!stored) throw new Error("daemon token was not stored");
+  return stored;
+}
+function readDaemonToken() {
+  try {
+    const raw = readFileSync(paths().token, "utf8").trim();
+    return isDaemonToken(raw) ? raw : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // ../protocol/src/session.ts
 import { z } from "zod";
@@ -115,62 +234,100 @@ function isArchived(s) {
   return s.archivedAt !== void 0;
 }
 
+// ../protocol/src/tasks.ts
+import { z as z2 } from "zod";
+var TASK_TITLE_MAX = 200;
+var TASK_TEXT_MAX = 2e4;
+var TaskSchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  text: z2.string().optional(),
+  giver: z2.string(),
+  giverName: z2.string(),
+  owner: z2.string(),
+  ownerName: z2.string(),
+  state: z2.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z2.string().optional(),
+  at: z2.string(),
+  updatedAt: z2.string(),
+  log: z2.array(z2.object({ at: z2.string(), by: z2.string(), what: z2.string() }))
+});
+var taskClosed = (t) => t.state === "done" || t.state === "refused" || t.state === "dropped";
+var TaskCmdSchema = z2.object({
+  type: z2.literal("task.cmd"),
+  rid: z2.string().min(1),
+  by: z2.string().min(1),
+  op: z2.enum(["give", "take", "done", "refuse", "pass", "show", "list"]),
+  task: z2.string().min(1).max(40).optional(),
+  to: z2.string().min(1).optional(),
+  title: z2.string().min(1).max(TASK_TITLE_MAX).optional(),
+  text: z2.string().max(TASK_TEXT_MAX).optional(),
+  all: z2.boolean().optional()
+});
+var TaskResultSchema = z2.object({
+  type: z2.literal("task.result"),
+  rid: z2.string(),
+  task: TaskSchema.optional(),
+  tasks: z2.array(TaskSchema).optional(),
+  reason: z2.string().optional()
+});
+
 // ../protocol/src/messages.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // ../protocol/src/chat.ts
-import { z as z2 } from "zod";
-var ChatStepSchema = z2.object({
-  kind: z2.enum(["sessions", "pane", "reply", "git", "repo"]),
-  id: z2.string().optional(),
-  name: z2.string().optional(),
-  path: z2.string().optional()
+import { z as z3 } from "zod";
+var ChatStepSchema = z3.object({
+  kind: z3.enum(["sessions", "pane", "reply", "git", "repo"]),
+  id: z3.string().optional(),
+  name: z3.string().optional(),
+  path: z3.string().optional()
 });
-var ChatProposalSchema = z2.object({
-  cwd: z2.string().min(1),
-  project: z2.string(),
-  prompt: z2.string().optional(),
+var ChatProposalSchema = z3.object({
+  cwd: z3.string().min(1),
+  project: z3.string(),
+  prompt: z3.string().optional(),
   tool: ToolSchema,
-  launchedId: z2.string().optional(),
-  error: z2.string().optional()
+  launchedId: z3.string().optional(),
+  error: z3.string().optional()
 });
 var MAX_PROPOSALS = 8;
-var ChatProposalsSchema = z2.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatRelaySchema = z2.object({
-  id: z2.string().min(1),
-  name: z2.string(),
+var ChatProposalsSchema = z3.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatRelaySchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string(),
   tool: ToolSchema,
-  text: z2.string().min(1),
-  status: z2.enum(["queued", "sent"]).optional(),
-  sentAt: z2.string().datetime().optional(),
-  error: z2.string().optional()
+  text: z3.string().min(1),
+  status: z3.enum(["queued", "sent"]).optional(),
+  sentAt: z3.string().datetime().optional(),
+  error: z3.string().optional()
 });
-var ChatCloseSchema = z2.object({
-  id: z2.string().min(1),
-  name: z2.string(),
+var ChatCloseSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string(),
   tool: ToolSchema,
-  closedAt: z2.string().datetime().optional(),
-  how: z2.enum(["exit", "killed"]).optional(),
-  error: z2.string().optional()
+  closedAt: z3.string().datetime().optional(),
+  how: z3.enum(["exit", "killed"]).optional(),
+  error: z3.string().optional()
 });
-var ChatClosesSchema = z2.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
-var ChatProjectProposalSchema = z2.object({
-  name: z2.string().min(1).max(80),
-  description: z2.string().max(500).optional(),
-  repos: z2.array(z2.object({ path: z2.string().min(1).max(4096), why: z2.string().min(1).max(200) })).min(1).max(50),
-  addTo: z2.string().min(1).max(80).optional()
+var ChatClosesSchema = z3.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
+var ChatProjectProposalSchema = z3.object({
+  name: z3.string().min(1).max(80),
+  description: z3.string().max(500).optional(),
+  repos: z3.array(z3.object({ path: z3.string().min(1).max(4096), why: z3.string().min(1).max(200) })).min(1).max(50),
+  addTo: z3.string().min(1).max(80).optional()
 });
-var ChatTurnSchema = z2.object({
-  machineId: z2.string().optional(),
-  machineName: z2.string().optional(),
-  choices: z2.array(z2.object({ id: z2.string(), label: z2.string() })).optional(),
-  qid: z2.string().min(1),
-  question: z2.string(),
-  askedAt: z2.string().datetime(),
-  steps: z2.array(ChatStepSchema),
-  answer: z2.string().optional(),
-  answeredAt: z2.string().datetime().optional(),
-  error: z2.string().optional(),
+var ChatTurnSchema = z3.object({
+  machineId: z3.string().optional(),
+  machineName: z3.string().optional(),
+  choices: z3.array(z3.object({ id: z3.string(), label: z3.string() })).optional(),
+  qid: z3.string().min(1),
+  question: z3.string(),
+  askedAt: z3.string().datetime(),
+  steps: z3.array(ChatStepSchema),
+  answer: z3.string().optional(),
+  answeredAt: z3.string().datetime().optional(),
+  error: z3.string().optional(),
   proposal: ChatProposalSchema.optional(),
   proposals: ChatProposalsSchema.optional(),
   relay: ChatRelaySchema.optional(),
@@ -180,70 +337,70 @@ var ChatTurnSchema = z2.object({
 var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
 
 // ../protocol/src/repos.ts
-import { z as z3 } from "zod";
-var ReposInspectSchema = z3.object({
-  type: z3.literal("repos.inspect"),
-  requestId: z3.string().min(1).max(100),
-  paths: z3.array(z3.string().min(1)).min(1).max(50),
-  machineId: z3.string().optional()
+import { z as z4 } from "zod";
+var ReposInspectSchema = z4.object({
+  type: z4.literal("repos.inspect"),
+  requestId: z4.string().min(1).max(100),
+  paths: z4.array(z4.string().min(1)).min(1).max(50),
+  machineId: z4.string().optional()
 });
-var RepoInfoSchema = z3.object({ path: z3.string(), exists: z3.boolean(), branch: z3.string().nullable() });
-var ReposInfoSchema = z3.object({ type: z3.literal("repos.info"), requestId: z3.string(), repos: z3.array(RepoInfoSchema) });
+var RepoInfoSchema = z4.object({ path: z4.string(), exists: z4.boolean(), branch: z4.string().nullable() });
+var ReposInfoSchema = z4.object({ type: z4.literal("repos.info"), requestId: z4.string(), repos: z4.array(RepoInfoSchema) });
 
 // ../protocol/src/models.ts
-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({
+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({
   id: ModelIdSchema,
-  label: z4.string(),
-  description: z4.string().optional(),
-  efforts: z4.array(EffortSchema).optional(),
+  label: z5.string(),
+  description: z5.string().optional(),
+  efforts: z5.array(EffortSchema).optional(),
   defaultEffort: EffortSchema.optional(),
-  isDefault: z4.boolean().optional()
+  isDefault: z5.boolean().optional()
 });
-var ModelsListSchema = z4.object({
-  type: z4.literal("models.list"),
-  requestId: z4.string().min(1).max(100),
+var ModelsListSchema = z5.object({
+  type: z5.literal("models.list"),
+  requestId: z5.string().min(1).max(100),
   tool: ToolSchema,
-  machineId: z4.string().optional()
+  machineId: z5.string().optional()
 });
-var ModelsListingSchema = z4.object({
-  type: z4.literal("models.listing"),
-  requestId: z4.string(),
+var ModelsListingSchema = z5.object({
+  type: z5.literal("models.listing"),
+  requestId: z5.string(),
   tool: ToolSchema,
-  models: z4.array(ModelChoiceSchema),
-  error: z4.string().optional()
+  models: z5.array(ModelChoiceSchema),
+  error: z5.string().optional()
 });
 
 // ../protocol/src/scan.ts
-import { z as z5 } from "zod";
-var ReposScanSchema = z5.object({ type: z5.literal("repos.scan"), requestId: z5.string().min(1).max(100), machineId: z5.string().optional() });
-var FoundRepoSchema = z5.object({ path: z5.string(), branch: z5.string().nullable(), remote: z5.string().optional(), manifest: z5.string().max(200).optional() });
-var ReposFoundSchema = z5.object({ type: z5.literal("repos.found"), requestId: z5.string(), repos: z5.array(FoundRepoSchema).max(500), truncated: z5.boolean(), error: z5.string().optional() });
+import { z as z6 } from "zod";
+var ReposScanSchema = z6.object({ type: z6.literal("repos.scan"), requestId: z6.string().min(1).max(100), machineId: z6.string().optional() });
+var FoundRepoSchema = z6.object({ path: z6.string(), branch: z6.string().nullable(), remote: z6.string().optional(), manifest: z6.string().max(200).optional() });
+var ReposFoundSchema = z6.object({ type: z6.literal("repos.found"), requestId: z6.string(), repos: z6.array(FoundRepoSchema).max(500), truncated: z6.boolean(), error: z6.string().optional() });
 
 // ../protocol/src/documents.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var DOCUMENT_MAX_BYTES = 1048576;
-var path = z6.string().min(1).max(4096);
-var requestId = z6.string().min(1);
-var DocumentReadSchema = z6.object({
-  type: z6.literal("document.read"),
+var path = z7.string().min(1).max(4096);
+var requestId = z7.string().min(1);
+var DocumentReadSchema = z7.object({
+  type: z7.literal("document.read"),
   requestId,
   path,
-  machineId: z6.string().optional(),
-  sessionId: z6.string().min(1).optional(),
+  machineId: z7.string().optional(),
+  sessionId: z7.string().min(1).optional(),
   basePath: path.optional()
 });
-var DocumentContentSchema = z6.object({
-  type: z6.literal("document.content"),
+var DocumentContentSchema = z7.object({
+  type: z7.literal("document.content"),
   requestId,
   path,
-  text: z6.string(),
-  bytes: z6.number().int().nonnegative(),
-  modifiedAt: z6.string().datetime()
+  text: z7.string(),
+  bytes: z7.number().int().nonnegative(),
+  modifiedAt: z7.string().datetime()
 });
-var DocumentErrorCodeSchema = z6.enum([
+var DocumentErrorCodeSchema = z7.enum([
   "not_found",
   "not_file",
   "unsupported_path",
@@ -255,47 +412,47 @@ var DocumentErrorCodeSchema = z6.enum([
   "session_missing",
   "read_failed"
 ]);
-var DocumentErrorSchema = z6.object({
-  type: z6.literal("document.error"),
+var DocumentErrorSchema = z7.object({
+  type: z7.literal("document.error"),
   requestId,
   path,
   code: DocumentErrorCodeSchema
 });
 
 // ../protocol/src/routing.ts
-import { z as z7 } from "zod";
-var MachineInventorySchema = z7.object({
-  id: z7.string().min(1).max(80),
-  label: z7.string().min(1).max(120),
-  online: z7.boolean(),
-  local: z7.boolean(),
-  sessions: z7.array(z7.object({ id: z7.string(), name: z7.string(), project: z7.string(), cwd: z7.string(), topic: z7.string().optional(), state: z7.string(), readOnly: z7.boolean() })).max(500),
-  folders: z7.array(z7.object({ project: z7.string(), cwd: z7.string() })).max(100)
+import { z as z8 } from "zod";
+var MachineInventorySchema = z8.object({
+  id: z8.string().min(1).max(80),
+  label: z8.string().min(1).max(120),
+  online: z8.boolean(),
+  local: z8.boolean(),
+  sessions: z8.array(z8.object({ id: z8.string(), name: z8.string(), project: z8.string(), cwd: z8.string(), topic: z8.string().optional(), state: z8.string(), readOnly: z8.boolean() })).max(500),
+  folders: z8.array(z8.object({ project: z8.string(), cwd: z8.string() })).max(100)
 });
-var RoutingContextSchema = z7.object({
-  machines: z7.array(MachineInventorySchema).min(1).max(20),
-  history: z7.array(z7.object({ question: z7.string().max(2e4), answer: z7.string().max(2e4).optional(), machineId: z7.string().optional() })).max(50)
+var RoutingContextSchema = z8.object({
+  machines: z8.array(MachineInventorySchema).min(1).max(20),
+  history: z8.array(z8.object({ question: z8.string().max(2e4), answer: z8.string().max(2e4).optional(), machineId: z8.string().optional() })).max(50)
 });
-var RouteResultSchema = z7.object({
+var RouteResultSchema = z8.object({
   /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z7.string().nullable(),
-  text: z7.string().min(1).max(2e4),
-  choices: z7.array(z7.string()).max(20).optional()
+  machineId: z8.string().nullable(),
+  text: z8.string().min(1).max(2e4),
+  choices: z8.array(z8.string()).max(20).optional()
 });
 
 // ../protocol/src/ssh.ts
-import { z as z8 } from "zod";
-var SshAliasSchema = z8.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
+import { z as z9 } from "zod";
+var SshAliasSchema = z9.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
 
 // ../protocol/src/machines.ts
-import { z as z9 } from "zod";
-var MachineIdSchema = z9.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
-var MachineSchema = z9.object({
+import { z as z10 } from "zod";
+var MachineIdSchema = z10.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var MachineSchema = z10.object({
   id: MachineIdSchema,
-  label: z9.string().trim().min(1).max(80),
+  label: z10.string().trim().min(1).max(80),
   ssh: SshAliasSchema.optional()
 });
-var MachinesSchema = z9.array(MachineSchema).min(1).max(20).superRefine((list, ctx) => {
+var MachinesSchema = z10.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) => {
@@ -310,52 +467,53 @@ var MachinesSchema = z9.array(MachineSchema).min(1).max(20).superRefine((list, c
 });
 
 // ../protocol/src/island.ts
-import { z as z10 } from "zod";
-var IslandScaleSchema = z10.union([z10.literal("auto"), z10.literal(1), z10.literal(1.25), z10.literal(1.5), z10.literal(2)]);
-var IslandPrefsSchema = z10.object({
+import { z as z11 } from "zod";
+var IslandScaleSchema = z11.union([z11.literal("auto"), z11.literal(1), z11.literal(1.25), z11.literal(1.5), z11.literal(2)]);
+var IslandPrefsSchema = z11.object({
   /** Shown at the top of the screen; hidden, Desktop still notifies. */
-  visible: z10.boolean(),
+  visible: z11.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: z10.string().trim().min(1).max(200),
-  position: z10.enum(["center", "left", "right"]),
+  screen: z11.string().trim().min(1).max(200),
+  position: z11.enum(["center", "left", "right"]),
   /** A strip under a maximised window. */
-  discreet: z10.boolean(),
+  discreet: z11.boolean(),
   islandScale: IslandScaleSchema,
   panelScale: IslandScaleSchema,
   /** What the island shows besides asks and questions, which it always shows. */
-  shows: z10.object({
+  shows: z11.object({
     /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
-    quick: z10.boolean(),
+    quick: z11.boolean(),
     /** The 6 s bubble when an agent finishes. */
-    finished: z10.boolean(),
+    finished: z11.boolean(),
     /** An agent's sentence in a bubble. */
-    say: z10.boolean(),
+    say: z11.boolean(),
     /** The sub-agents next to their main agent. */
-    helpers: z10.boolean()
+    helpers: z11.boolean()
   }),
   /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
-  shortcut: z10.string().trim().min(1).max(40)
+  shortcut: z11.string().trim().min(1).max(40)
 });
 
 // ../protocol/src/projects.ts
-import { z as z11 } from "zod";
-var ProjectColorSchema = z11.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
-var ProjectIdSchema = z11.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+import { z as z12 } from "zod";
+var PROJECT_COLORS = { blue: "#3b82f6", green: "#10b981", amber: "#f59e0b", violet: "#8b5cf6", teal: "#14b8a6", pink: "#ec4899", red: "#ef4444", slate: "#64748b" };
+var ProjectColorSchema = z12.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
+var ProjectIdSchema = z12.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 = z11.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
-var RepoSchema = z11.object({ machine: MachineIdSchema, path: PathSchema });
-var ProjectSchema = z11.object({
+var PathSchema = z12.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
+var RepoSchema = z12.object({ machine: MachineIdSchema, path: PathSchema });
+var ProjectSchema = z12.object({
   id: ProjectIdSchema,
-  name: z11.string().trim().min(1).max(80),
+  name: z12.string().trim().min(1).max(80),
   color: ProjectColorSchema,
-  description: z11.string().max(500).default(""),
-  repos: z11.array(RepoSchema).max(50)
+  description: z12.string().max(500).default(""),
+  repos: z12.array(RepoSchema).max(50)
 });
-var RuleSchema = z11.object({ machine: MachineIdSchema, path: PathSchema, project: ProjectIdSchema });
+var RuleSchema = z12.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();
@@ -381,7 +539,7 @@ ${rule.path}`;
   });
   return out;
 }
-var ProjectsSchema = z11.object({ projects: z11.array(ProjectSchema).max(100), rules: z11.array(RuleSchema).max(1e3) }).superRefine((p, ctx) => {
+var ProjectsSchema = z12.object({ projects: z12.array(ProjectSchema).max(100), rules: z12.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: [] };
@@ -399,47 +557,47 @@ function projectOf(session, state) {
 }
 
 // ../protocol/src/thread.ts
-import { z as z12 } from "zod";
-var ToolStatusSchema = z12.enum(["running", "success", "failed", "unknown"]);
-var FileChangeSchema = z12.object({ path: z12.string().min(1), from: z12.string().min(1).optional(), change: z12.enum(["add", "edit", "delete", "write"]), diff: z12.string().optional() });
-var base = { id: z12.string().min(1), at: z12.string().datetime(), turn: z12.number().int().nonnegative(), helperId: z12.string().optional() };
-var ThreadItemSchema = z12.discriminatedUnion("kind", [
-  z12.object({ kind: z12.literal("prompt"), ...base, text: z12.string() }),
-  z12.object({ kind: z12.literal("message"), ...base, text: z12.string() }),
+import { z as z13 } from "zod";
+var ToolStatusSchema = z13.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z13.object({ path: z13.string().min(1), from: z13.string().min(1).optional(), change: z13.enum(["add", "edit", "delete", "write"]), diff: z13.string().optional() });
+var base = { id: z13.string().min(1), at: z13.string().datetime(), turn: z13.number().int().nonnegative(), helperId: z13.string().optional() };
+var ThreadItemSchema = z13.discriminatedUnion("kind", [
+  z13.object({ kind: z13.literal("prompt"), ...base, text: z13.string() }),
+  z13.object({ kind: z13.literal("message"), ...base, text: z13.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. */
-  z12.object({ kind: z12.literal("tool"), ...base, tool: z12.string(), label: z12.string(), input: z12.string().optional(), output: z12.string().optional(), error: z12.string().optional(), status: ToolStatusSchema, durationMs: z12.number().nonnegative().optional(), files: z12.array(FileChangeSchema).default([]), byClose: z12.literal(true).optional() }),
+  z13.object({ kind: z13.literal("tool"), ...base, tool: z13.string(), label: z13.string(), input: z13.string().optional(), output: z13.string().optional(), error: z13.string().optional(), status: ToolStatusSchema, durationMs: z13.number().nonnegative().optional(), files: z13.array(FileChangeSchema).default([]), byClose: z13.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. */
-  z12.object({ kind: z12.literal("permission"), ...base, tool: z12.string(), text: z12.string(), decision: z12.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z12.literal(true).optional() }),
-  z12.object({ kind: z12.literal("reply"), ...base, text: z12.string() }),
-  z12.object({ kind: z12.literal("helper"), ...base, task: z12.string(), agentType: z12.string().optional(), state: z12.enum(["working", "exited"]) }),
+  z13.object({ kind: z13.literal("permission"), ...base, tool: z13.string(), text: z13.string(), decision: z13.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z13.literal(true).optional() }),
+  z13.object({ kind: z13.literal("reply"), ...base, text: z13.string() }),
+  z13.object({ kind: z13.literal("helper"), ...base, task: z13.string(), agentType: z13.string().optional(), state: z13.enum(["working", "exited"]) }),
   /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread, `via` set when Ledge's mailbox carries it. */
-  z12.object({ kind: z12.literal("sent"), ...base, to: z12.string(), peer: z12.string().optional(), summary: z12.string().optional(), text: z12.string(), status: z12.enum(["sending", "delivered", "read", "failed"]), received: z12.string().optional(), via: z12.literal("ledge").optional() }),
+  z13.object({ kind: z13.literal("sent"), ...base, to: z13.string(), peer: z13.string().optional(), summary: z13.string().optional(), text: z13.string(), status: z13.enum(["sending", "delivered", "read", "failed"]), received: z13.string().optional(), via: z13.literal("ledge").optional() }),
   /** A message another agent sent to this session; `from` is its from-name (else its address), `sent` the paired item's id in the peer's thread. */
-  z12.object({ kind: z12.literal("received"), ...base, from: z12.string(), peer: z12.string().optional(), text: z12.string(), sent: z12.string().optional() }),
+  z13.object({ kind: z13.literal("received"), ...base, from: z13.string(), peer: z13.string().optional(), text: z13.string(), sent: z13.string().optional() }),
   /** An automated notice of the agent's harness about messages between sessions (Claude Code's `[Cross-session idle
    *  notice]` / `[Cross-session delivery notice]`): a system event, never the user's words. `name` is the session it is
    *  about as quoted, `peer` its Ledge session id; a delivery notice says the outcome of `count` messages to `recipients`. */
-  z12.object({
-    kind: z12.literal("notice"),
+  z13.object({
+    kind: z13.literal("notice"),
     ...base,
-    notice: z12.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
-    name: z12.string().optional(),
-    peer: z12.string().optional(),
-    time: z12.string().optional(),
-    summary: z12.string().optional(),
-    status: z12.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
-    count: z12.number().int().positive().optional(),
-    recipients: z12.array(z12.string()).optional(),
-    reason: z12.string().optional(),
-    text: z12.string()
+    notice: z13.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
+    name: z13.string().optional(),
+    peer: z13.string().optional(),
+    time: z13.string().optional(),
+    summary: z13.string().optional(),
+    status: z13.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
+    count: z13.number().int().positive().optional(),
+    recipients: z13.array(z13.string()).optional(),
+    reason: z13.string().optional(),
+    text: z13.string()
   })
 ]);
 
 // ../protocol/src/decisions.ts
-import { z as z13 } from "zod";
-var DecisionSchema = z13.enum(["accept", "deny", "always"]);
+import { z as z14 } from "zod";
+var DecisionSchema = z14.enum(["accept", "deny", "always"]);
 var NOTE_MAX = 4e3;
 var NOTE_NOT_TYPED = "note_not_typed";
 var DECISION_OFFERS = {
@@ -469,12 +627,12 @@ function pendingKey(p) {
 }
 
 // ../protocol/src/mobile.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var DEFAULT_RELAY_URL = "https://app.kl-ledge.dev";
-var RelayUrlSchema = z14.string().transform((v, ctx) => {
+var RelayUrlSchema = z15.string().transform((v, ctx) => {
   const bad = () => {
-    ctx.addIssue({ code: z14.ZodIssueCode.custom, message: "invalid relay URL" });
-    return z14.NEVER;
+    ctx.addIssue({ code: z15.ZodIssueCode.custom, message: "invalid relay URL" });
+    return z15.NEVER;
   };
   let u;
   try {
@@ -487,108 +645,108 @@ var RelayUrlSchema = z14.string().transform((v, ctx) => {
   if (u.username || u.password || u.pathname !== "/" || u.search || u.hash) return bad();
   return u.origin;
 });
-var MobileConfigSchema = z14.object({ enabled: z14.boolean(), relayUrl: RelayUrlSchema });
-var MobileLinkStateSchema = z14.discriminatedUnion("state", [
-  z14.object({ state: z14.literal("off") }),
-  z14.object({ state: z14.literal("connecting") }),
-  z14.object({ state: z14.literal("online") }),
-  z14.object({ state: z14.literal("offline"), retryAt: z14.string().datetime(), error: z14.string() }),
-  z14.object({ state: z14.literal("signed_out"), reason: z14.enum(["other_pc", "session_invalid"]) }),
+var MobileConfigSchema = z15.object({ enabled: z15.boolean(), relayUrl: RelayUrlSchema });
+var MobileLinkStateSchema = z15.discriminatedUnion("state", [
+  z15.object({ state: z15.literal("off") }),
+  z15.object({ state: z15.literal("connecting") }),
+  z15.object({ state: z15.literal("online") }),
+  z15.object({ state: z15.literal("offline"), retryAt: z15.string().datetime(), error: z15.string() }),
+  z15.object({ state: z15.literal("signed_out"), reason: z15.enum(["other_pc", "session_invalid"]) }),
   /** The mobile service did not start (a broken mobile.json, a missing key store): nothing is linked until the daemon restarts. */
-  z14.object({ state: z14.literal("unavailable"), error: z14.string().max(200) })
+  z15.object({ state: z15.literal("unavailable"), error: z15.string().max(200) })
 ]);
-var MobilePairingSchema = z14.object({
-  id: z14.string(),
-  label: z14.string(),
-  code: z14.string().nullable(),
-  expiresAt: z14.string().datetime(),
-  state: z14.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
+var MobilePairingSchema = z15.object({
+  id: z15.string(),
+  label: z15.string(),
+  code: z15.string().nullable(),
+  expiresAt: z15.string().datetime(),
+  state: z15.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
 });
-var MobileStateSchema = z14.object({
-  enabled: z14.boolean(),
-  relayUrl: z14.string(),
-  account: z14.object({ login: z14.string(), accountId: z14.string() }).nullable(),
-  signin: z14.object({ userCode: z14.string(), verificationUri: z14.string(), expiresAt: z14.string().datetime() }).nullable(),
+var MobileStateSchema = z15.object({
+  enabled: z15.boolean(),
+  relayUrl: z15.string(),
+  account: z15.object({ login: z15.string(), accountId: z15.string() }).nullable(),
+  signin: z15.object({ userCode: z15.string(), verificationUri: z15.string(), expiresAt: z15.string().datetime() }).nullable(),
   /** The last sign-in that did not end with a session; cleared by the next one. */
-  signinError: z14.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
+  signinError: z15.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
   link: MobileLinkStateSchema,
-  devices: z14.array(z14.object({ id: z14.string(), label: z14.string(), approvedAt: z14.string(), online: z14.boolean(), lastSeenAt: z14.string().optional() })),
-  pairings: z14.array(MobilePairingSchema)
+  devices: z15.array(z15.object({ id: z15.string(), label: z15.string(), approvedAt: z15.string(), online: z15.boolean(), lastSeenAt: z15.string().optional() })),
+  pairings: z15.array(MobilePairingSchema)
 });
 
 // ../protocol/src/messages.ts
 var PROTOCOL_PORT = 47831;
-var RefusalCodeSchema = z15.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid"]);
-var SessionEventSchema = z15.object({
-  name: z15.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
-  at: z15.string().datetime(),
-  source: z15.enum(["hook", "pane", "daemon"]),
-  tool: z15.string().optional(),
-  text: z15.string().optional(),
-  options: z15.array(z15.string()).optional(),
+var RefusalCodeSchema = z16.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid"]);
+var SessionEventSchema = z16.object({
+  name: z16.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
+  at: z16.string().datetime(),
+  source: z16.enum(["hook", "pane", "daemon"]),
+  tool: z16.string().optional(),
+  text: z16.string().optional(),
+  options: z16.array(z16.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z15.array(z15.string()).optional(),
-  kind: z15.enum(["question", "permission", "plan", "diff"]).optional(),
+  optionDetails: z16.array(z16.string()).optional(),
+  kind: z16.enum(["question", "permission", "plan", "diff"]).optional(),
   /** PanePrompt: what to review in full before deciding (a plan read in the terminal), when `text` is its summary. */
-  body: z15.string().optional(),
-  exitCode: z15.number().int().nullable().optional(),
-  helperId: z15.string().optional(),
+  body: z16.string().optional(),
+  exitCode: z16.number().int().nullable().optional(),
+  helperId: z16.string().optional(),
   /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z15.string().optional(),
+  task: z16.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z15.boolean().optional(),
+  interrupt: z16.boolean().optional(),
   /** QueueUpdate: OMP's queue as it stands. */
-  queue: z15.array(z15.object({ text: z15.string(), mode: z15.enum(["steer", "follow_up"]) })).optional(),
+  queue: z16.array(z16.object({ text: z16.string(), mode: z16.enum(["steer", "follow_up"]) })).optional(),
   /** AgentMessage: the harness's own message, its text so far (`streaming`) or whole. `messageId` is unique for the session's life. */
-  messageId: z15.string().optional(),
-  streaming: z15.boolean().optional(),
+  messageId: z16.string().optional(),
+  streaming: z16.boolean().optional(),
   /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
-  requestId: z15.string().optional(),
-  questions: z15.array(AskQuestionSchema).optional(),
+  requestId: z16.string().optional(),
+  questions: z16.array(AskQuestionSchema).optional(),
   /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
-  streamed: z15.boolean().optional(),
+  streamed: z16.boolean().optional(),
   /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
-  toolUseId: z15.string().optional(),
+  toolUseId: z16.string().optional(),
   /** The tool's input as the harness gave it, every string capped by the hook. */
-  toolInput: z15.record(z15.string(), z15.unknown()).optional(),
+  toolInput: z16.record(z16.string(), z16.unknown()).optional(),
   /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z15.string().optional(),
-  durationMs: z15.number().nonnegative().optional(),
+  output: z16.string().optional(),
+  durationMs: z16.number().nonnegative().optional(),
   /** PostToolUseFailure: the harness's error message. */
-  error: z15.string().optional(),
+  error: z16.string().optional(),
   /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
-  transcriptPath: z15.string().optional(),
+  transcriptPath: z16.string().optional(),
   /** Decided: what was chosen when the daemon knows it. */
   decision: DecisionSchema.optional(),
   /** Decided: the request was refused by Ledge closing the session (its interrupt keys), not by the user's answer. */
-  byClose: z15.literal(true).optional(),
+  byClose: z16.literal(true).optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
-  agentSessionId: z15.string().optional()
+  agentSessionId: z16.string().optional()
 });
-var RecentSchema = z15.object({ cwd: z15.string().min(1), project: z15.string().min(1), lastAt: z15.string().datetime() });
+var RecentSchema = z16.object({ cwd: z16.string().min(1), project: z16.string().min(1), lastAt: z16.string().datetime() });
 var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z15.object({
-  version: z15.string(),
-  install: z15.enum(["npm", "git", "unknown"]),
-  systemd: z15.boolean(),
-  manual: z15.string().optional(),
-  routing: z15.boolean().optional(),
-  archive: z15.boolean().optional(),
+var DaemonInfoSchema = z16.object({
+  version: z16.string(),
+  install: z16.enum(["npm", "git", "unknown"]),
+  systemd: z16.boolean(),
+  manual: z16.string().optional(),
+  routing: z16.boolean().optional(),
+  archive: z16.boolean().optional(),
   /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
-  models: z15.boolean().optional(),
+  models: z16.boolean().optional(),
   /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
-  omp: z15.boolean().optional(),
+  omp: z16.boolean().optional(),
   /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
-  modelSwitch: z15.boolean().optional(),
+  modelSwitch: z16.boolean().optional(),
   /** Takes `approval` on an OMP `session.launch` (auto mode). */
-  ompApproval: z15.boolean().optional(),
+  ompApproval: z16.boolean().optional(),
   /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
-  home: z15.string().optional(),
-  mobile: z15.boolean().optional()
+  home: z16.string().optional(),
+  mobile: z16.boolean().optional()
 });
-var UpdateFailureSchema = z15.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z15.discriminatedUnion("type", [
-  z15.object({ type: z15.literal("chat.routed"), qid: z15.string(), result: RouteResultSchema }),
+var UpdateFailureSchema = z16.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z16.discriminatedUnion("type", [
+  z16.object({ type: z16.literal("chat.routed"), qid: z16.string(), result: RouteResultSchema }),
   DocumentContentSchema,
   DocumentErrorSchema,
   ReposInfoSchema,
@@ -597,69 +755,72 @@ var ServerMessageSchema = z15.discriminatedUnion("type", [
   /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
    *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
    *  from daemons older than the auto-update. */
-  z15.object({ type: z15.literal("snapshot"), sessions: z15.array(SessionSchema), recents: z15.array(RecentSchema).optional(), launcher: z15.array(z15.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
-  z15.object({ type: z15.literal("session.updated"), session: SessionSchema }),
+  z16.object({ type: z16.literal("snapshot"), sessions: z16.array(SessionSchema), recents: z16.array(RecentSchema).optional(), launcher: z16.array(z16.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z16.object({ type: z16.literal("session.updated"), session: SessionSchema }),
   /** OMP: the instructions taken back from its queue by an interrupt that restores it; the asker puts them back in its draft. */
-  z15.object({ type: z15.literal("session.queue.restored"), id: z15.string(), texts: z15.array(z15.string()) }),
-  z15.object({ type: z15.literal("session.removed"), id: z15.string() }),
-  z15.object({ type: z15.literal("session.preview"), id: z15.string(), lines: z15.array(z15.string()) }),
+  z16.object({ type: z16.literal("session.queue.restored"), id: z16.string(), texts: z16.array(z16.string()) }),
+  z16.object({ type: z16.literal("session.removed"), id: z16.string() }),
+  z16.object({ type: z16.literal("session.preview"), id: z16.string(), lines: z16.array(z16.string()) }),
   /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
-  z15.object({ type: z15.literal("session.thread"), id: z15.string(), items: z15.array(ThreadItemSchema) }),
-  z15.object({ type: z15.literal("session.thread.item"), id: z15.string(), item: ThreadItemSchema }),
+  z16.object({ type: z16.literal("session.thread"), id: z16.string(), items: z16.array(ThreadItemSchema) }),
+  z16.object({ type: z16.literal("session.thread.item"), id: z16.string(), item: ThreadItemSchema }),
   /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
-  z15.object({ type: z15.literal("session.launched"), id: z15.string() }),
+  z16.object({ type: z16.literal("session.launched"), id: z16.string() }),
   /** Answer to the requester of a `session.close`, once per row closed: the session `id` and how it ended. */
-  z15.object({ type: z15.literal("session.closed"), qid: z15.string(), row: z15.number().int().min(0), id: z15.string(), how: z15.enum(["exit", "killed"]) }),
-  z15.object({ type: z15.literal("recents"), recents: z15.array(RecentSchema) }),
+  z16.object({ type: z16.literal("session.closed"), qid: z16.string(), row: z16.number().int().min(0), id: z16.string(), how: z16.enum(["exit", "killed"]) }),
+  z16.object({ type: z16.literal("recents"), recents: z16.array(RecentSchema) }),
   /** Answer to the requester of a `folder.list` or `folder.create`: `path` resolved (`~` expanded), `parent` null at the
    *  root, `entries` its subfolders by name (hidden ones left out). A failure keeps the asked path and says why in `error`,
    *  never in an `error` message, which the launch form reads as a failed launch. */
-  z15.object({
-    type: z15.literal("folder.listing"),
-    path: z15.string(),
-    parent: z15.string().nullable(),
-    entries: z15.array(z15.string()),
-    error: z15.string().optional(),
+  z16.object({
+    type: z16.literal("folder.listing"),
+    path: z16.string(),
+    parent: z16.string().nullable(),
+    entries: z16.array(z16.string()),
+    error: z16.string().optional(),
     /** The request this answers, when it carried one. */
-    requestId: z15.string().optional(),
+    requestId: z16.string().optional(),
     /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
-    repos: z15.array(z15.object({ name: z15.string(), branch: z15.string() })).optional()
+    repos: z16.array(z16.object({ name: z16.string(), branch: z16.string() })).optional()
   }),
   /** The chat (spec 2026-10-11 §5): what Ledge reads, its words as they come, the final text, or why it stopped; the day's turns after each snapshot. */
-  z15.object({ type: z15.literal("chat.step"), qid: z15.string(), step: ChatStepSchema }),
-  z15.object({ type: z15.literal("chat.delta"), qid: z15.string(), text: z15.string() }),
-  z15.object({ type: z15.literal("chat.done"), qid: z15.string(), text: z15.string(), at: z15.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
-  z15.object({ type: z15.literal("chat.error"), qid: z15.string(), message: z15.string() }),
-  z15.object({ type: z15.literal("chat.history"), turns: z15.array(ChatTurnSchema) }),
+  z16.object({ type: z16.literal("chat.step"), qid: z16.string(), step: ChatStepSchema }),
+  z16.object({ type: z16.literal("chat.delta"), qid: z16.string(), text: z16.string() }),
+  z16.object({ type: z16.literal("chat.done"), qid: z16.string(), text: z16.string(), at: z16.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
+  z16.object({ type: z16.literal("chat.error"), qid: z16.string(), message: z16.string() }),
+  z16.object({ type: z16.literal("chat.history"), turns: z16.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
-  z15.object({ type: z15.literal("update.progress"), version: z15.string(), step: z15.enum(["installing", "restarting"]) }),
+  z16.object({ type: z16.literal("update.progress"), version: z16.string(), step: z16.enum(["installing", "restarting"]) }),
   /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
-  z15.object({ type: z15.literal("update.failed"), version: z15.string(), reason: UpdateFailureSchema, detail: z15.string().optional(), command: z15.string().optional() }),
+  z16.object({ type: z16.literal("update.failed"), version: z16.string(), reason: UpdateFailureSchema, detail: z16.string().optional(), command: z16.string().optional() }),
   /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z15.object({ type: z15.literal("machines"), machines: MachinesSchema }),
+  z16.object({ type: z16.literal("machines"), machines: MachinesSchema }),
   /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
-  z15.object({ type: z15.literal("projects"), projects: ProjectsSchema }),
+  z16.object({ type: z16.literal("projects"), projects: ProjectsSchema }),
   /** The island's settings shared by the local fronts; null until a front sets them (the island then sends its own). Local clients only. */
-  z15.object({ type: z15.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  z16.object({ type: z16.literal("island"), prefs: IslandPrefsSchema.nullable() }),
   /** Mobile access (lot 3), after the island in each snapshot and on every change. Local clients only. */
-  z15.object({ type: z15.literal("mobile"), state: MobileStateSchema }),
+  z16.object({ type: z16.literal("mobile"), state: MobileStateSchema }),
   /** The daemon's immediate answer to a `session.message`: delivered (`accepted`), held for later (`queued`), left to Claude's own SendMessage (`native`), or refused with a `reason`. */
-  z15.object({ type: z15.literal("message.ack"), rid: z15.string(), outcome: z15.enum(["accepted", "queued", "native", "refused"]), reason: z15.string().optional() }),
-  z15.object({
-    type: z15.literal("error"),
-    message: z15.string(),
-    id: z15.string().optional(),
+  z16.object({ type: z16.literal("message.ack"), rid: z16.string(), outcome: z16.enum(["accepted", "queued", "native", "refused"]), reason: z16.string().optional() }),
+  /** The answer to a `message.read`: the body with its sender, target and time, or the refusal's `reason`. */
+  z16.object({ type: z16.literal("message.body"), id: z16.string(), from: z16.string().optional(), to: z16.string().optional(), at: z16.string().optional(), text: z16.string().optional(), reason: z16.string().optional() }),
+  TaskResultSchema,
+  z16.object({
+    type: z16.literal("error"),
+    message: z16.string(),
+    id: z16.string().optional(),
     /** Le type du message client refusé. */
-    request: z15.string().optional(),
+    request: z16.string().optional(),
     /** Ce que le front doit reconnaître au-delà du texte (NOTE_NOT_TYPED) ; une chaîne libre, qu'un front plus ancien ignore. */
-    code: z15.string().optional()
+    code: z16.string().optional()
   })
 ]);
 var MESSAGE_MAX = 2e4;
 var SUMMARY_MAX = 500;
-var launchRows = z15.array(z15.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var ClientMessageSchema = z15.discriminatedUnion("type", [
-  z15.object({ type: z15.literal("chat.route"), qid: z15.string().min(1).max(100), text: z15.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+var launchRows = z16.array(z16.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var ClientMessageSchema = z16.discriminatedUnion("type", [
+  z16.object({ type: z16.literal("chat.route"), qid: z16.string().min(1).max(100), text: z16.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
   ReposInspectSchema,
   ReposScanSchema,
@@ -668,114 +829,117 @@ var ClientMessageSchema = z15.discriminatedUnion("type", [
    *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
    *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields
    *  but `rows`, `model` and `effort`. */
-  z15.object({
-    type: z15.literal("session.launch"),
+  z16.object({
+    type: z16.literal("session.launch"),
     tool: ToolSchema,
-    cwd: z15.string().min(1),
-    name: z15.string().optional(),
-    prompt: z15.string().optional(),
-    continue: z15.boolean().optional(),
-    qid: z15.string().min(1).optional(),
+    cwd: z16.string().min(1),
+    name: z16.string().optional(),
+    prompt: z16.string().optional(),
+    continue: z16.boolean().optional(),
+    qid: z16.string().min(1).optional(),
     /** With `qid`: the card's rows to launch (#24), indexes into the turn's `proposals`, each once; the first row without it. */
     rows: launchRows.optional(),
     /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
-    dirs: z15.array(z15.string().min(1)).max(20).optional(),
+    dirs: z16.array(z16.string().min(1)).max(20).optional(),
     /** The agent's model and effort (#58), the agent's own default when left out; with `qid`, for every row launched. */
     model: ModelIdSchema.optional(),
     effort: EffortSchema.optional(),
     /** OMP only: its approval mode, `always-ask` when left out. */
     approval: OmpApprovalSchema.optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z15.string().optional()
+    machineId: z16.string().optional()
   }),
   /** The launch form's folder browser: list a folder's subfolders (home when no `path`), or make `name` inside `parent`
    *  and list it. Both are answered with a `folder.listing`. */
-  z15.object({
-    type: z15.literal("folder.list"),
-    path: z15.string().optional(),
+  z16.object({
+    type: z16.literal("folder.list"),
+    path: z16.string().optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z15.string().optional(),
+    machineId: z16.string().optional(),
     /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
-    requestId: z15.string().min(1).max(100).optional()
+    requestId: z16.string().min(1).max(100).optional()
   }),
-  z15.object({
-    type: z15.literal("folder.create"),
-    parent: z15.string().min(1),
-    name: z15.string().min(1),
+  z16.object({
+    type: z16.literal("folder.create"),
+    parent: z16.string().min(1),
+    name: z16.string().min(1),
     /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
-    machineId: z15.string().optional(),
-    requestId: z15.string().min(1).max(100).optional()
+    machineId: z16.string().optional(),
+    requestId: z16.string().min(1).max(100).optional()
   }),
   /** `steer`: OMP only, redirect the turn running now instead of queueing the text after it. */
   /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order (`selected` labels, and/or free `text`); `cancel` declines it. */
-  z15.object({ type: z15.literal("session.answer"), id: z15.string(), requestId: z15.string().min(1).max(200), answers: z15.array(z15.object({ id: z15.string(), selected: z15.array(z15.string().max(2e3)).max(100), text: z15.string().max(2e4).optional() })).max(50), cancel: z15.boolean().optional() }),
-  z15.object({ type: z15.literal("session.reply"), id: z15.string(), text: z15.string().min(1), steer: z15.boolean().optional() }),
+  z16.object({ type: z16.literal("session.answer"), id: z16.string(), requestId: z16.string().min(1).max(200), answers: z16.array(z16.object({ id: z16.string(), selected: z16.array(z16.string().max(2e3)).max(100), text: z16.string().max(2e4).optional() })).max(50), cancel: z16.boolean().optional() }),
+  z16.object({ type: z16.literal("session.reply"), id: z16.string(), text: z16.string().min(1), steer: z16.boolean().optional() }),
   /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
-  z15.object({ type: z15.literal("session.relay"), qid: z15.string().min(1) }),
+  z16.object({ type: z16.literal("session.relay"), qid: z16.string().min(1) }),
   /** Takes the card's queued instruction back out of the queue. */
-  z15.object({ type: z15.literal("session.relay.cancel"), qid: z15.string().min(1) }),
+  z16.object({ type: z16.literal("session.relay.cancel"), qid: z16.string().min(1) }),
   /** The chat's close card: closes the turn's sessions, `rows` (indexes into its `closes`) or all of them. */
-  z15.object({ type: z15.literal("session.close"), qid: z15.string().min(1), rows: launchRows.optional() }),
+  z16.object({ type: z16.literal("session.close"), qid: z16.string().min(1), rows: launchRows.optional() }),
   /** `always` and `note` only where the harness offers them (`offers`); a note goes with `deny`, for the agent to read. */
-  z15.object({
-    type: z15.literal("session.decide"),
-    id: z15.string(),
+  z16.object({
+    type: z16.literal("session.decide"),
+    id: z16.string(),
     decision: DecisionSchema,
-    note: z15.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z16.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the user saw when deciding: refused (the request changed) unless it is still the pending one. Left out by older fronts and the island.
      *  `key` (pendingKey) covers its whole content; older fronts send kind and text only. */
-    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z15.string().max(64).optional() }).optional()
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z16.string().max(64).optional() }).optional()
   }),
-  z15.object({ type: z15.literal("session.focus"), id: z15.string() }),
-  z15.object({ type: z15.literal("session.kill"), id: z15.string() }),
+  z16.object({ type: z16.literal("session.focus"), id: z16.string() }),
+  z16.object({ type: z16.literal("session.kill"), id: z16.string() }),
   /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
-  z15.object({ type: z15.literal("session.interrupt"), id: z15.string(), restoreQueue: z15.boolean().optional() }),
+  z16.object({ type: z16.literal("session.interrupt"), id: z16.string(), restoreQueue: z16.boolean().optional() }),
   /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
-  z15.object({ type: z15.literal("session.dismiss"), id: z15.string() }),
+  z16.object({ type: z16.literal("session.dismiss"), id: z16.string() }),
   /** Puts a session in the archive: it leaves the live list but is kept. */
-  z15.object({ type: z15.literal("session.archive"), id: z15.string() }),
+  z16.object({ type: z16.literal("session.archive"), id: z16.string() }),
   /** Takes an archived session back out of the archive, as it was. */
-  z15.object({ type: z15.literal("session.restore"), id: z15.string() }),
+  z16.object({ type: z16.literal("session.restore"), id: z16.string() }),
   /** Starts the agent again on an archived session's conversation. */
-  z15.object({ type: z15.literal("session.resume"), id: z15.string() }),
+  z16.object({ type: z16.literal("session.resume"), id: z16.string() }),
   /** Changes a live session's model and effort (#58, lot 2), `null` for the agent's own default: the daemon restarts the
    *  agent on the same conversation with them, at once when the session is free, else at its next free moment. */
-  z15.object({ type: z15.literal("session.model"), id: z15.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  z16.object({ type: z16.literal("session.model"), id: z16.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** Deletes a session for good, archived or not. */
-  z15.object({ type: z15.literal("session.delete"), id: z15.string() }),
+  z16.object({ type: z16.literal("session.delete"), id: z16.string() }),
   /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
-  z15.object({ type: z15.literal("session.rename"), id: z15.string(), topic: z15.string().max(500) }),
-  z15.object({ type: z15.literal("session.thread"), id: z15.string() }),
-  z15.object({ type: z15.literal("session.register"), session: SessionSchema }),
+  z16.object({ type: z16.literal("session.rename"), id: z16.string(), topic: z16.string().max(500) }),
+  z16.object({ type: z16.literal("session.thread"), id: z16.string() }),
+  z16.object({ type: z16.literal("session.register"), session: SessionSchema }),
   /** `agent` and `cwd` describe the session when the daemon does not know it yet (a hook from an agent started without ledge). */
-  z15.object({ type: z15.literal("session.event"), id: z15.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z15.string().optional() }),
-  z15.object({ type: z15.literal("session.unregister"), id: z15.string(), exitCode: z15.number().int().nullable() }),
-  z15.object({ type: z15.literal("snapshot.request") }),
-  z15.object({ type: z15.literal("chat.ask"), qid: z15.string().min(1), text: z15.string().min(1), tool: ToolSchema.optional() }),
-  z15.object({ type: z15.literal("chat.cancel"), qid: z15.string().min(1) }),
+  z16.object({ type: z16.literal("session.event"), id: z16.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z16.string().optional() }),
+  z16.object({ type: z16.literal("session.unregister"), id: z16.string(), exitCode: z16.number().int().nullable() }),
+  z16.object({ type: z16.literal("snapshot.request") }),
+  z16.object({ type: z16.literal("chat.ask"), qid: z16.string().min(1), text: z16.string().min(1), tool: ToolSchema.optional() }),
+  z16.object({ type: z16.literal("chat.cancel"), qid: z16.string().min(1) }),
   /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
-  z15.object({ type: z15.literal("chat.reset") }),
+  z16.object({ type: z16.literal("chat.reset") }),
   /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
-  z15.object({ type: z15.literal("update.daemon"), version: z15.string().regex(SEMVER) }),
+  z16.object({ type: z16.literal("update.daemon"), version: z16.string().regex(SEMVER) }),
   /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
-  z15.object({ type: z15.literal("machines.set"), machines: MachinesSchema }),
+  z16.object({ type: z16.literal("machines.set"), machines: MachinesSchema }),
   /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
-  z15.object({ type: z15.literal("projects.set"), projects: ProjectsSchema }),
+  z16.object({ type: z16.literal("projects.set"), projects: ProjectsSchema }),
   /** Replaces the island's settings as a whole; refused unless valid. */
-  z15.object({ type: z15.literal("island.set"), prefs: IslandPrefsSchema }),
+  z16.object({ type: z16.literal("island.set"), prefs: IslandPrefsSchema }),
   /** Mobile access (lot 3), local fronts only. A changed `relayUrl` drops the relay session. */
-  z15.object({ type: z15.literal("mobile.set"), enabled: z15.boolean(), relayUrl: RelayUrlSchema }),
-  z15.object({ type: z15.literal("mobile.signin") }),
-  z15.object({ type: z15.literal("mobile.signin.cancel") }),
-  z15.object({ type: z15.literal("mobile.signout") }),
+  z16.object({ type: z16.literal("mobile.set"), enabled: z16.boolean(), relayUrl: RelayUrlSchema }),
+  z16.object({ type: z16.literal("mobile.signin") }),
+  z16.object({ type: z16.literal("mobile.signin.cancel") }),
+  z16.object({ type: z16.literal("mobile.signout") }),
   /** While the link is offline: try again now. */
-  z15.object({ type: z15.literal("mobile.retry") }),
-  z15.object({ type: z15.literal("mobile.pairing.approve"), id: z15.string().min(1).max(100) }),
-  z15.object({ type: z15.literal("mobile.pairing.deny"), id: z15.string().min(1).max(100) }),
+  z16.object({ type: z16.literal("mobile.retry") }),
+  z16.object({ type: z16.literal("mobile.pairing.approve"), id: z16.string().min(1).max(100) }),
+  z16.object({ type: z16.literal("mobile.pairing.deny"), id: z16.string().min(1).max(100) }),
   /** `id`: the device's fingerprint. */
-  z15.object({ type: z15.literal("mobile.device.revoke"), id: z15.string().min(1).max(100) }),
+  z16.object({ type: z16.literal("mobile.device.revoke"), id: z16.string().min(1).max(100) }),
   /** One session writing to another by Ledge name (`to` may end in ` [ref]`); `intercept` (the Claude hook): answer `native` unless `to` is a live non-Claude session. */
-  z15.object({ type: z15.literal("session.message"), rid: z15.string().min(1), from: z15.string().min(1), to: z15.string().min(1), text: z15.string().min(1).max(MESSAGE_MAX), summary: z15.string().max(SUMMARY_MAX).optional(), intercept: z15.boolean().optional() })
+  z16.object({ type: z16.literal("session.message"), rid: z16.string().min(1), from: z16.string().min(1), to: z16.string().min(1), text: z16.string().min(1).max(MESSAGE_MAX), summary: z16.string().max(SUMMARY_MAX).optional(), intercept: z16.boolean().optional() }),
+  /** `ledge read <id>`: a message's whole body, for its receiver or its sender (`by`, a session id). */
+  z16.object({ type: z16.literal("message.read"), id: z16.string().min(1).max(40), by: z16.string().min(1) }),
+  TaskCmdSchema
 ]);
 function parseClientMessage(raw) {
   return ClientMessageSchema.parse(raw);
@@ -867,16 +1031,16 @@ function pickName(taken, preferred) {
 }
 
 // ../protocol/src/proposal.ts
-import { z as z16 } from "zod";
-var ProposalBlockSchema = z16.object({ cwd: z16.string().trim().min(1), prompt: z16.string().optional() });
-var RelayBlockSchema = z16.object({ session: z16.string().trim().min(1), text: z16.string().trim().min(1) });
-var ProjectBlockSchema = z16.object({
-  name: z16.string().trim().min(1).max(80),
-  description: z16.string().max(500).optional(),
-  repos: z16.array(z16.object({ path: z16.string().min(1).max(4096), why: z16.string().trim().min(1).max(200) })).min(1).max(50),
-  addTo: z16.string().trim().max(80).optional()
+import { z as z17 } from "zod";
+var ProposalBlockSchema = z17.object({ cwd: z17.string().trim().min(1), prompt: z17.string().optional() });
+var RelayBlockSchema = z17.object({ session: z17.string().trim().min(1), text: z17.string().trim().min(1) });
+var ProjectBlockSchema = z17.object({
+  name: z17.string().trim().min(1).max(80),
+  description: z17.string().max(500).optional(),
+  repos: z17.array(z17.object({ path: z17.string().min(1).max(4096), why: z17.string().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z17.string().trim().max(80).optional()
 });
-var CloseBlockSchema = z16.object({ session: z16.string().trim().min(1) });
+var CloseBlockSchema = z17.object({ session: z17.string().trim().min(1) });
 var BLOCK = /```ledge-(session|relay|project|close)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
 function extractProposal(answer) {
   const found = [];
@@ -932,80 +1096,80 @@ function sessionTitle(s) {
 }
 
 // ../protocol/src/relay.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var SEALED_MAX = 1048576;
-var RelayPeerSchema = z17.union([z17.literal("pc"), z17.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
-var RelayClientMessageSchema = z17.object({
-  type: z17.literal("send"),
+var RelayPeerSchema = z18.union([z18.literal("pc"), z18.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
+var RelayClientMessageSchema = z18.object({
+  type: z18.literal("send"),
   to: RelayPeerSchema,
-  body: z17.string().max(SEALED_MAX)
+  body: z18.string().max(SEALED_MAX)
 });
-var RelayServerMessageSchema = z17.discriminatedUnion("type", [
-  z17.object({ type: z17.literal("welcome"), accountId: z17.string(), self: RelayPeerSchema, online: z17.array(RelayPeerSchema) }),
-  z17.object({ type: z17.literal("deliver"), from: RelayPeerSchema, body: z17.string() }),
-  z17.object({ type: z17.literal("presence"), peer: RelayPeerSchema, online: z17.boolean() }),
+var RelayServerMessageSchema = z18.discriminatedUnion("type", [
+  z18.object({ type: z18.literal("welcome"), accountId: z18.string(), self: RelayPeerSchema, online: z18.array(RelayPeerSchema) }),
+  z18.object({ type: z18.literal("deliver"), from: RelayPeerSchema, body: z18.string() }),
+  z18.object({ type: z18.literal("presence"), peer: RelayPeerSchema, online: z18.boolean() }),
   /**
    * A frame was refused; `to` names the target when it is known.
    * Contract: an error concerning a sealed body (`offline`, `too_large`, or a socket closed with 4008
    * `rate_limited`) means that body was not delivered, so the sequence on that channel is lost: the
    * sender must re-handshake with that peer before sending to it again.
    */
-  z17.object({
-    type: z17.literal("error"),
-    code: z17.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
+  z18.object({
+    type: z18.literal("error"),
+    code: z18.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
     to: RelayPeerSchema.optional()
   })
 ]);
 var PAIR_LABEL_MAX = 40;
-var KeyB64 = z17.string().regex(/^[A-Za-z0-9_-]{87}$/);
-var Nonce = z17.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var Fingerprint = z17.string().regex(/^[A-Za-z0-9_-]{22}$/);
-var SealedFrameSchema = z17.discriminatedUnion("k", [
+var KeyB64 = z18.string().regex(/^[A-Za-z0-9_-]{87}$/);
+var Nonce = z18.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var Fingerprint = z18.string().regex(/^[A-Za-z0-9_-]{22}$/);
+var SealedFrameSchema = z18.discriminatedUnion("k", [
   /** `e` is the ephemeral key, `f` the fingerprint of the sender's static key. */
-  z17.object({ k: z17.literal("hello"), e: KeyB64, f: Fingerprint }),
-  z17.object({ k: z17.literal("msg"), s: z17.string() }),
-  z17.object({ k: z17.literal("pair_commit"), c: Nonce, label: z17.string().trim().min(1).max(PAIR_LABEL_MAX) }),
-  z17.object({ k: z17.literal("pair_offer"), pc: KeyB64, n: Nonce }),
-  z17.object({ k: z17.literal("pair_reveal"), d: KeyB64, n: Nonce }),
-  z17.object({ k: z17.literal("pair_ok") }),
-  z17.object({ k: z17.literal("pair_no") }),
-  z17.object({ k: z17.literal("denied") }),
-  z17.object({ k: z17.literal("rekey") })
+  z18.object({ k: z18.literal("hello"), e: KeyB64, f: Fingerprint }),
+  z18.object({ k: z18.literal("msg"), s: z18.string() }),
+  z18.object({ k: z18.literal("pair_commit"), c: Nonce, label: z18.string().trim().min(1).max(PAIR_LABEL_MAX) }),
+  z18.object({ k: z18.literal("pair_offer"), pc: KeyB64, n: Nonce }),
+  z18.object({ k: z18.literal("pair_reveal"), d: KeyB64, n: Nonce }),
+  z18.object({ k: z18.literal("pair_ok") }),
+  z18.object({ k: z18.literal("pair_no") }),
+  z18.object({ k: z18.literal("denied") }),
+  z18.object({ k: z18.literal("rekey") })
 ]);
 
 // ../protocol/src/relayAuth.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var RELAY_CLOSE_SIGNED_OUT = 4001;
-var DeviceStartResponseSchema = z18.object({
-  deviceCode: z18.string().min(1),
-  userCode: z18.string().min(1),
-  verificationUri: z18.string().min(1),
-  expiresIn: z18.number().int().positive(),
-  interval: z18.number().int().positive()
+var DeviceStartResponseSchema = z19.object({
+  deviceCode: z19.string().min(1),
+  userCode: z19.string().min(1),
+  verificationUri: z19.string().min(1),
+  expiresIn: z19.number().int().positive(),
+  interval: z19.number().int().positive()
 });
-var DevicePollResponseSchema = z18.discriminatedUnion("status", [
-  z18.object({ status: z18.literal("pending") }),
-  z18.object({ status: z18.literal("slow_down"), interval: z18.number().int().positive() }),
+var DevicePollResponseSchema = z19.discriminatedUnion("status", [
+  z19.object({ status: z19.literal("pending") }),
+  z19.object({ status: z19.literal("slow_down"), interval: z19.number().int().positive() }),
   /** `token` is the relay session token, shown this once only. */
-  z18.object({ status: z18.literal("ok"), token: z18.string().min(1), accountId: z18.string().min(1), login: z18.string().min(1) }),
-  z18.object({ status: z18.literal("expired") }),
-  z18.object({ status: z18.literal("denied") }),
-  z18.object({ status: z18.literal("not_allowed") })
+  z19.object({ status: z19.literal("ok"), token: z19.string().min(1), accountId: z19.string().min(1), login: z19.string().min(1) }),
+  z19.object({ status: z19.literal("expired") }),
+  z19.object({ status: z19.literal("denied") }),
+  z19.object({ status: z19.literal("not_allowed") })
 ]);
-var DeviceRevokeResponseSchema = z18.object({ revoked: z18.number().int().min(0) });
-var MeResponseSchema = z18.object({
-  accountId: z18.string().min(1),
-  login: z18.string().min(1),
+var DeviceRevokeResponseSchema = z19.object({ revoked: z19.number().int().min(0) });
+var MeResponseSchema = z19.object({
+  accountId: z19.string().min(1),
+  login: z19.string().min(1),
   peer: RelayPeerSchema,
-  kind: z18.enum(["pc", "device"])
+  kind: z19.enum(["pc", "device"])
 });
 
 // ../protocol/src/phone.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // ../protocol/src/push.ts
-import { z as z19 } from "zod";
-var B64U = z19.string().regex(/^[A-Za-z0-9_-]*$/);
+import { z as z20 } from "zod";
+var B64U = z20.string().regex(/^[A-Za-z0-9_-]*$/);
 var PUSH_HOSTS = ["*.push.apple.com", "fcm.googleapis.com", "updates.push.services.mozilla.com", "*.notify.windows.com"];
 function pushEndpointAllowed(url) {
   let u;
@@ -1022,29 +1186,29 @@ function pushEndpointAllowed(url) {
     return host.length > suffix.length && host.endsWith(suffix);
   });
 }
-var PushSendSchema = z19.object({
-  endpoint: z19.string().url().max(1024),
+var PushSendSchema = z20.object({
+  endpoint: z20.string().url().max(1024),
   body: B64U.max(5462),
-  ttl: z19.number().int().min(0).max(86400),
-  urgency: z19.enum(["normal", "high"]),
-  topic: z19.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+  ttl: z20.number().int().min(0).max(86400),
+  urgency: z20.enum(["normal", "high"]),
+  topic: z20.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
 });
-var PushSendResultSchema = z19.object({
-  result: z19.enum(["sent", "gone", "failed"]),
-  status: z19.number().int().optional()
+var PushSendResultSchema = z20.object({
+  result: z20.enum(["sent", "gone", "failed"]),
+  status: z20.number().int().optional()
 });
-var PushSubscriptionSchema = z19.object({
-  endpoint: z19.string().url().max(1024).refine(pushEndpointAllowed),
-  keys: z19.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
+var PushSubscriptionSchema = z20.object({
+  endpoint: z20.string().url().max(1024).refine(pushEndpointAllowed),
+  keys: z20.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
 });
-var PushPayloadSchema = z19.object({
-  v: z19.literal(1),
-  kind: z19.enum(["request", "question", "finished", "chat"]),
-  title: z19.string().max(80),
-  body: z19.string().max(120),
-  url: z19.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
-  badge: z19.number().int().min(0).max(999),
-  tag: z19.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+var PushPayloadSchema = z20.object({
+  v: z20.literal(1),
+  kind: z20.enum(["request", "question", "finished", "chat"]),
+  title: z20.string().max(80),
+  body: z20.string().max(120),
+  url: z20.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
+  badge: z20.number().int().min(0).max(999),
+  tag: z20.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
 });
 
 // ../protocol/src/phone.ts
@@ -1065,22 +1229,22 @@ var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var PENDING_BODY_MAX = 65536;
 var SNAPSHOT_BODY_MAX = 2048;
-var RiskSchema = z20.enum(["low", "high"]);
-var RiskReasonSchema = z20.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 = z20.string().uuid();
-var OperationStatusSchema = z20.enum(["received", "applied", "rejected", "failed"]);
-var OperationReasonSchema = z20.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired"]);
-var CapabilitiesSchema = z20.object({
+var RiskSchema = z21.enum(["low", "high"]);
+var RiskReasonSchema = z21.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 = z21.string().uuid();
+var OperationStatusSchema = z21.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z21.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired"]);
+var CapabilitiesSchema = z21.object({
   /** A question can be answered in free text. */
-  freeTextAnswer: z20.boolean(),
+  freeTextAnswer: z21.boolean(),
   /** The session's accept/deny can be typed; absent = true. */
-  decide: z20.boolean().optional(),
+  decide: z21.boolean().optional(),
   /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z20.boolean().optional()
+  questions: z21.boolean().optional()
 });
 var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
-var CapabilitiesByToolSchema = z20.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
-var PhonePendingSchema = PendingSchema.extend({ key: z20.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z20.literal(true).optional() });
+var CapabilitiesByToolSchema = z21.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z21.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z21.literal(true).optional() });
 var PhoneSessionSchema = SessionSchema.pick({
   id: true,
   name: true,
@@ -1096,272 +1260,160 @@ var PhoneSessionSchema = SessionSchema.pick({
   lastReply: true,
   startedAt: true,
   lastActivityAt: true
-}).extend({ pending: PhonePendingSchema.optional(), unread: z20.boolean() });
-var B64U2 = z20.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z20.object({
+}).extend({ pending: PhonePendingSchema.optional(), unread: z21.boolean() });
+var B64U2 = z21.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z21.object({
   id: B64U2.max(1366),
   publicKey: B64U2.max(2048),
-  alg: z20.union([z20.literal(-7), z20.literal(-257)]),
+  alg: z21.union([z21.literal(-7), z21.literal(-257)]),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
-  transports: z20.array(z20.string().max(20)).max(8).optional()
+  transports: z21.array(z21.string().max(20)).max(8).optional()
 });
-var AssertionSchema = z20.object({
+var AssertionSchema = z21.object({
   id: B64U2.max(1366),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
   signature: B64U2.max(1024)
 });
-var ConfirmPurposeSchema = z20.enum(["register", "decide", "launch", "close"]);
+var ConfirmPurposeSchema = z21.enum(["register", "decide", "launch", "close"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z20.object({
-  project: z20.string().max(80),
+var PhoneChatProposalSchema = z21.object({
+  project: z21.string().max(80),
   tool: ToolSchema,
-  prompt: z20.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z20.string().optional(),
-  failed: z20.literal(true).optional()
+  prompt: z21.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z21.string().optional(),
+  failed: z21.literal(true).optional()
 }).strict();
-var PhoneChatRelaySchema = z20.object({
-  id: z20.string().min(1),
-  name: z20.string(),
+var PhoneChatRelaySchema = z21.object({
+  id: z21.string().min(1),
+  name: z21.string(),
   tool: ToolSchema,
-  text: z20.string().max(TOOL_TEXT_MAX),
-  status: z20.enum(["queued", "sent"]).optional(),
-  sentAt: z20.string().datetime().optional(),
-  failed: z20.literal(true).optional()
+  text: z21.string().max(TOOL_TEXT_MAX),
+  status: z21.enum(["queued", "sent"]).optional(),
+  sentAt: z21.string().datetime().optional(),
+  failed: z21.literal(true).optional()
 }).strict();
-var PhoneChatCloseSchema = z20.object({
-  id: z20.string().min(1),
-  name: z20.string(),
+var PhoneChatCloseSchema = z21.object({
+  id: z21.string().min(1),
+  name: z21.string(),
   tool: ToolSchema,
-  how: z20.enum(["exit", "killed"]).optional(),
-  closedAt: z20.string().datetime().optional(),
-  failed: z20.literal(true).optional()
+  how: z21.enum(["exit", "killed"]).optional(),
+  closedAt: z21.string().datetime().optional(),
+  failed: z21.literal(true).optional()
 }).strict();
-var ChatErrorCodeSchema = z20.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z20.object({
+var ChatErrorCodeSchema = z21.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z21.object({
   qid: OperationIdSchema,
-  question: z20.string().max(MESSAGE_MAX),
-  askedAt: z20.string().datetime(),
-  steps: z20.array(PhoneChatStepSchema).max(50),
-  answer: z20.string().max(THREAD_TEXT_MAX).optional(),
-  answeredAt: z20.string().datetime().optional(),
+  question: z21.string().max(MESSAGE_MAX),
+  askedAt: z21.string().datetime(),
+  steps: z21.array(PhoneChatStepSchema).max(50),
+  answer: z21.string().max(THREAD_TEXT_MAX).optional(),
+  answeredAt: z21.string().datetime().optional(),
   error: ChatErrorCodeSchema.optional(),
-  proposals: z20.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  proposals: z21.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
   relay: PhoneChatRelaySchema.optional(),
-  closes: z20.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
-  cut: z20.literal(true).optional()
+  closes: z21.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
+  cut: z21.literal(true).optional()
 }).strict();
 var CHAT_HISTORY_BUDGET = 393216;
-var sessionId = z20.string().min(1).max(100);
-var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z20.string().min(1).max(64) });
-var CardRowsSchema = z20.array(z20.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var PhoneClientMessageSchema = z20.discriminatedUnion("type", [
-  z20.object({ type: z20.literal("snapshot.request") }),
-  z20.object({ type: z20.literal("session.thread"), id: sessionId }),
+var sessionId = z21.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z21.string().min(1).max(64) });
+var CardRowsSchema = z21.array(z21.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var PhoneClientMessageSchema = z21.discriminatedUnion("type", [
+  z21.object({ type: z21.literal("snapshot.request") }),
+  z21.object({ type: z21.literal("session.thread"), id: sessionId }),
   /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
-  z20.object({ type: z20.literal("session.pending"), id: sessionId }),
+  z21.object({ type: z21.literal("session.pending"), id: sessionId }),
   /** The session whose terminal the phone shows; null when it shows none. */
-  z20.object({ type: z20.literal("session.watch"), id: sessionId.nullable() }),
-  z20.object({ type: z20.literal("session.read"), id: sessionId, at: z20.string().datetime() }),
+  z21.object({ type: z21.literal("session.watch"), id: sessionId.nullable() }),
+  z21.object({ type: z21.literal("session.read"), id: sessionId, at: z21.string().datetime() }),
   /** Asks for a challenge. One object for both purposes: the gateway refuses a `decide` without `id` and `expect`. */
-  z20.object({ type: z20.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
-  z20.object({ type: z20.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z20.object({
-    type: z20.literal("session.decide"),
+  z21.object({ type: z21.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
+  z21.object({ type: z21.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z21.object({
+    type: z21.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z20.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z21.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the phone showed: refused unless it is still the pending one. */
     expect: PhoneExpectSchema,
     /** The device check over the challenge of `confirm.prepare`; required by the daemon for a high-risk accept. */
     assertion: AssertionSchema.optional()
   }),
-  z20.object({
-    type: z20.literal("session.reply"),
+  z21.object({
+    type: z21.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z20.string().min(1).max(MESSAGE_MAX),
+    text: z21.string().min(1).max(MESSAGE_MAX),
     /** The request the reply answers, or null when the phone showed none: refused if the session's request is no longer that one. */
     expect: PhoneExpectSchema.nullable(),
     assertion: AssertionSchema.optional()
   }),
   /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order; `cancel` declines it. Bounds as the local `session.answer`. */
-  z20.object({
-    type: z20.literal("session.answer"),
+  z21.object({
+    type: z21.literal("session.answer"),
     op: OperationIdSchema,
     id: sessionId,
-    requestId: z20.string().min(1).max(200),
-    answers: z20.array(z20.object({ id: z20.string().max(200), selected: z20.array(z20.string().max(2e3)).max(100), text: z20.string().max(2e4).optional() })).max(50),
-    cancel: z20.literal(true).optional(),
+    requestId: z21.string().min(1).max(200),
+    answers: z21.array(z21.object({ id: z21.string().max(200), selected: z21.array(z21.string().max(2e3)).max(100), text: z21.string().max(2e4).optional() })).max(50),
+    cancel: z21.literal(true).optional(),
     expect: PhoneExpectSchema
   }),
-  z20.object({ type: z20.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  z21.object({ type: z21.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
   /** The phone drops its passkey from the daemon. */
-  z20.object({ type: z20.literal("device.forget"), op: OperationIdSchema }),
+  z21.object({ type: z21.literal("device.forget"), op: OperationIdSchema }),
   /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z20.object({ type: z20.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
-  z20.object({ type: z20.literal("push.unsubscribe"), op: OperationIdSchema }),
+  z21.object({ type: z21.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z21.object({ type: z21.literal("push.unsubscribe"), op: OperationIdSchema }),
   /** The phone's own chat with Ledge. */
-  z20.object({ type: z20.literal("chat.ask"), qid: OperationIdSchema, text: z20.string().trim().min(1).max(MESSAGE_MAX) }),
-  z20.object({ type: z20.literal("chat.cancel"), qid: OperationIdSchema }),
-  z20.object({ type: z20.literal("chat.reset") }),
-  z20.object({ type: z20.literal("chat.history") }),
-  z20.object({ type: z20.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
-  z20.object({ type: z20.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
-  z20.object({ type: z20.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z21.object({ type: z21.literal("chat.ask"), qid: OperationIdSchema, text: z21.string().trim().min(1).max(MESSAGE_MAX) }),
+  z21.object({ type: z21.literal("chat.cancel"), qid: OperationIdSchema }),
+  z21.object({ type: z21.literal("chat.reset") }),
+  z21.object({ type: z21.literal("chat.history") }),
+  z21.object({ type: z21.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z21.object({ type: z21.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z21.object({ type: z21.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
   /** Whether the phone's app is in front: a device that is visible gets no push. */
-  z20.object({ type: z20.literal("presence"), visible: z20.boolean() })
+  z21.object({ type: z21.literal("presence"), visible: z21.boolean() })
 ]);
-var PhoneServerMessageSchema = z20.discriminatedUnion("type", [
-  z20.object({ type: z20.literal("snapshot"), protocol: z20.literal(PHONE_PROTOCOL), sessions: z20.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z20.object({ version: z20.string(), name: z20.string().max(40), boot: z20.string().uuid().optional() }), device: z20.object({ confirm: z20.boolean(), push: z20.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z20.literal(true).optional() }).optional() }),
-  z20.object({ type: z20.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z20.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z20.number().int().positive() }),
-  z20.object({ type: z20.literal("session.updated"), session: PhoneSessionSchema }),
-  z20.object({ type: z20.literal("session.removed"), id: z20.string() }),
+var PhoneServerMessageSchema = z21.discriminatedUnion("type", [
+  z21.object({ type: z21.literal("snapshot"), protocol: z21.literal(PHONE_PROTOCOL), sessions: z21.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z21.object({ version: z21.string(), name: z21.string().max(40), boot: z21.string().uuid().optional() }), device: z21.object({ confirm: z21.boolean(), push: z21.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z21.literal(true).optional() }).optional() }),
+  z21.object({ type: z21.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z21.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z21.number().int().positive() }),
+  z21.object({ type: z21.literal("session.updated"), session: PhoneSessionSchema }),
+  z21.object({ type: z21.literal("session.removed"), id: z21.string() }),
   /** `pending.cut` is set when even this body was shortened. */
-  z20.object({ type: z20.literal("session.pending"), id: z20.string(), pending: PhonePendingSchema }),
-  z20.object({ type: z20.literal("session.preview"), id: z20.string(), lines: z20.array(z20.string()) }),
+  z21.object({ type: z21.literal("session.pending"), id: z21.string(), pending: PhonePendingSchema }),
+  z21.object({ type: z21.literal("session.preview"), id: z21.string(), lines: z21.array(z21.string()) }),
   /** `cut`: the ids of the items shortened; `more`: older items were left out. */
-  z20.object({ type: z20.literal("session.thread"), id: z20.string(), items: z20.array(ThreadItemSchema), cut: z20.array(z20.string()), more: z20.boolean() }),
-  z20.object({ type: z20.literal("session.thread.item"), id: z20.string(), item: ThreadItemSchema, cut: z20.literal(true).optional() }),
-  z20.object({ type: z20.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
-  z20.object({ type: z20.literal("chat.history"), turns: z20.array(PhoneChatTurnSchema).max(50) }),
-  z20.object({ type: z20.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  z21.object({ type: z21.literal("session.thread"), id: z21.string(), items: z21.array(ThreadItemSchema), cut: z21.array(z21.string()), more: z21.boolean() }),
+  z21.object({ type: z21.literal("session.thread.item"), id: z21.string(), item: ThreadItemSchema, cut: z21.literal(true).optional() }),
+  z21.object({ type: z21.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
+  z21.object({ type: z21.literal("chat.history"), turns: z21.array(PhoneChatTurnSchema).max(50) }),
+  z21.object({ type: z21.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
   /** The whole text so far, not an increment. */
-  z20.object({ type: z20.literal("chat.delta"), qid: OperationIdSchema, text: z20.string().max(THREAD_TEXT_MAX) }),
-  z20.object({ type: z20.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
-  z20.object({ type: z20.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
+  z21.object({ type: z21.literal("chat.delta"), qid: OperationIdSchema, text: z21.string().max(THREAD_TEXT_MAX) }),
+  z21.object({ type: z21.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z21.object({ type: z21.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
   /** Never carries free text. */
-  z20.object({ type: z20.literal("error"), code: z20.enum(["invalid", "unknown_session", "too_large"]), request: z20.string().max(40).optional() })
+  z21.object({ type: z21.literal("error"), code: z21.enum(["invalid", "unknown_session", "too_large"]), request: z21.string().max(40).optional() })
 ]);
 
-// src/auth.ts
-import { createHash, 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;
-  }
-  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);
-  }
-  return "";
-}
-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;
-  }
-  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;
-  }
-}
-async function lockTokenFile(file) {
-  await chmod(file, 384);
-}
-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;
-  }
-  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);
-  try {
-    await link(tmp, file);
-  } 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 });
-  }
-  await unlink(tmp).catch(() => {
-  });
-  await lockTokenFile(file);
-  const stored = await readTokenFile(file);
-  if (!stored) throw new Error("daemon token was not stored");
-  return stored;
-}
-function readDaemonToken() {
-  try {
-    const raw = readFileSync(paths().token, "utf8").trim();
-    return isDaemonToken(raw) ? raw : void 0;
-  } catch {
-    return void 0;
-  }
-}
-
 export {
+  hostAllowed,
+  requestAuthorized,
+  selectDaemonProtocol,
+  ensureDaemonToken,
+  readDaemonToken,
   ToolSchema,
   SessionSchema,
   backendOf,
   isArchived,
   MAX_PROPOSALS,
+  ChatTurnSchema,
   proposalRows,
+  NOTE_MAX,
   NOTE_NOT_TYPED,
   offers,
   pendingKey,
@@ -1369,6 +1421,7 @@ export {
   SshAliasSchema,
   MachinesSchema,
   IslandPrefsSchema,
+  PROJECT_COLORS,
   ProjectsSchema,
   DEFAULT_PROJECTS,
   projectOf,
@@ -1377,6 +1430,9 @@ export {
   RouteResultSchema,
   DEFAULT_RELAY_URL,
   MobileConfigSchema,
+  TASK_TITLE_MAX,
+  TASK_TEXT_MAX,
+  taskClosed,
   PROTOCOL_PORT,
   RefusalCodeSchema,
   RecentSchema,
@@ -1414,10 +1470,5 @@ export {
   OperationIdSchema,
   UNTYPABLE,
   CHAT_HISTORY_BUDGET,
-  PhoneClientMessageSchema,
-  hostAllowed,
-  requestAuthorized,
-  selectDaemonProtocol,
-  ensureDaemonToken,
-  readDaemonToken
+  PhoneClientMessageSchema
 };