@paradow/ledge 0.20.0 → 0.22.0

package/dist/cli/chunk-EX66KH66.js

@@ -1,1856 +0,0 @@
-import {
-  paths
-} from "./chunk-HOOHS3MX.js";
-
-// ../protocol/src/handover.ts
-import { z } from "zod";
-var ContextSchema = z.object({ used: z.number().int().min(0), window: z.number().int().positive(), at: z.string().datetime() });
-var CONTEXT_NEAR = 0.8;
-var CONTEXT_NEAR_MIN = 0.5;
-var CONTEXT_NEAR_MAX = 0.95;
-var ContextPrefsSchema = z.object({ near: z.number().min(CONTEXT_NEAR_MIN).max(CONTEXT_NEAR_MAX) });
-var contextShare = (c) => c ? Math.min(1, c.used / c.window) : void 0;
-var contextNear = (c, near = CONTEXT_NEAR) => (contextShare(c) ?? 0) >= near;
-var HandoverStateSchema = z.enum(["briefing", "launching", "done", "failed"]);
-var HandoverSchema = z.object({
-  state: HandoverStateSchema,
-  at: z.string().datetime(),
-  /** The relief, once launched. */
-  to: z.string().optional(),
-  toName: z.string().optional(),
-  reason: z.string().optional(),
-  /** Started by Ledge itself (a seat working without asking), not by the user. */
-  auto: z.literal(true).optional()
-});
-var RelievesSchema = z.object({ id: z.string(), name: z.string(), at: z.string().datetime() });
-var BRIEF_MAX = 2e4;
-var ContextSetSchema = z.object({ type: z.literal("context.set"), prefs: ContextPrefsSchema });
-var ContextPrefsMessageSchema = z.object({ type: z.literal("context.prefs"), prefs: ContextPrefsSchema });
-var SessionHandoverSchema = z.object({ type: z.literal("session.handover"), rid: z.string().min(1).max(100), id: z.string().min(1) });
-var HandoverBriefSchema = z.object({ type: z.literal("handover.brief"), rid: z.string().min(1).max(100), by: z.string().min(1), text: z.string().min(1).max(BRIEF_MAX) });
-var HandoverShowSchema = z.object({ type: z.literal("handover.show"), rid: z.string().min(1).max(100), by: z.string().min(1) });
-var SessionHandoverResultSchema = z.object({ type: z.literal("session.handover.result"), rid: z.string(), ok: z.boolean(), reason: z.string().optional() });
-var HandoverResultSchema = z.object({ type: z.literal("handover.result"), rid: z.string(), text: z.string().optional(), reason: z.string().optional() });
-
-// ../protocol/src/session.ts
-import { z as z2 } from "zod";
-var ToolSchema = z2.enum(["claude", "codex", "cursor", "omp"]);
-var OmpApprovalSchema = z2.enum(["always-ask", "write", "yolo"]);
-var AutonomySchema = z2.enum(["ask", "edits", "auto"]);
-var BackendSchema = z2.enum(["tmux", "omp-rpc"]);
-var SessionStateSchema = z2.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
-var AskQuestionSchema = z2.object({
-  id: z2.string(),
-  question: z2.string(),
-  header: z2.string().optional(),
-  multi: z2.boolean().optional(),
-  options: z2.array(z2.object({ label: z2.string(), description: z2.string().optional() }))
-});
-var PendingSchema = z2.object({
-  kind: z2.enum(["question", "permission", "plan", "diff"]),
-  text: z2.string(),
-  /** What to review in full before deciding, when `text` is only its summary: a plan's markdown. */
-  body: z2.string().optional(),
-  tool: z2.string().optional(),
-  options: z2.array(z2.string()).optional(),
-  /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z2.array(z2.string()).optional(),
-  /** `rpc`: the harness's own protocol asked (OMP): answered on its request id, never by typing. */
-  source: z2.enum(["hook", "pane", "rpc"]),
-  /** OMP: every question of one `ask` call, answered together with `session.answer`; `requestId` is the dialog it answers. */
-  questions: z2.array(AskQuestionSchema).optional(),
-  requestId: z2.string().optional(),
-  /** Set when the request comes from a helper (subagent): it is routed through its parent. */
-  helperId: z2.string().optional(),
-  /** For a helper-routed request: the state the parent returns to once it is answered (main thread may stop meanwhile). */
-  parentState: SessionStateSchema.optional()
-});
-var ReplySchema = z2.object({
-  text: z2.string(),
-  at: z2.string().datetime(),
-  /** The reply is a plan the agent proposes (Codex Plan mode): nothing in it is done yet. */
-  plan: z2.boolean().optional()
-});
-var HelperSchema = z2.object({
-  id: z2.string(),
-  kind: z2.string(),
-  task: z2.string(),
-  state: SessionStateSchema,
-  /** When this helper finished; retained across daemon restarts until its five-minute expiry. */
-  finishedAt: z2.string().datetime().optional()
-});
-var TopicSourceSchema = z2.enum(["user", "pane", "prompt"]);
-var SessionSchema = z2.object({
-  /** Origin is annotated by the overlay, never used as an unqualified session id on the wire. */
-  machineId: z2.string().optional(),
-  machineName: z2.string().optional(),
-  repoId: z2.string().optional(),
-  /** Annotated by the fleet when its machine is unreachable and the last snapshot is kept (keepStale, spec 2026-10-14 §6). */
-  offline: z2.boolean().optional(),
-  id: z2.string().min(1),
-  name: z2.string().min(1),
-  tool: ToolSchema,
-  cwd: z2.string(),
-  project: z2.string(),
-  title: z2.string(),
-  /** One line saying what the session is about (spec 2026-10-11 §3). */
-  topic: z2.string().optional(),
-  topicSource: TopicSourceSchema.optional(),
-  /** The repository (its main worktree's folder name and absolute path), the checked-out branch, and whether `cwd` is a linked worktree (§4). */
-  repo: z2.string().optional(),
-  repoPath: z2.string().optional(),
-  branch: z2.string().optional(),
-  worktree: z2.boolean().optional(),
-  /** The folder the agent works in now, as its last hook reported it: `cwd` stays where it started, this follows a worktree it entered. */
-  workdir: z2.string().optional(),
-  tmuxSession: z2.string().nullable(),
-  /** Left out for a tmux session. `omp-rpc`: no pane, nothing to attach to; the daemon holds the process (see `agentSessionFile`). */
-  backend: BackendSchema.optional(),
-  state: SessionStateSchema,
-  pending: PendingSchema.optional(),
-  helpers: z2.array(HelperSchema).default([]),
-  /** OMP: the instructions waiting in its own queue (typed while it works), as it reports them; left out when none. */
-  queue: z2.array(z2.object({ text: z2.string(), mode: z2.enum(["steer", "follow_up"]) })).optional(),
-  lastReply: ReplySchema.optional(),
-  /** The last message this session sent to another agent: its tool_use_id, the address, the peer's Ledge session id, a one-line summary. */
-  lastMessage: z2.object({ id: z2.string(), to: z2.string(), peer: z2.string().optional(), summary: z2.string(), at: z2.string().datetime() }).optional(),
-  startedAt: z2.string().datetime(),
-  lastActivityAt: z2.string().datetime(),
-  lastHookAt: z2.string().datetime().optional(),
-  /** The model and effort Ledge launched the agent with (#58); left out, the agent's own default. */
-  model: z2.string().optional(),
-  effort: z2.string().optional(),
-  /** OMP: the approval mode it was launched with, kept by a resume; left out, `always-ask`. */
-  approval: OmpApprovalSchema.optional(),
-  /** The role it was launched with or took in a team (spec 2026-10-25 roles §3.3): its id, its label as it was then. */
-  role: z2.string().optional(),
-  roleLabel: z2.string().optional(),
-  /** The live team it sits in (`team-…`); left out, the project's common table. */
-  team: z2.string().optional(),
-  /** Its role's autonomy, as launched (kept by a resume); left out, `ask`. */
-  autonomy: AutonomySchema.optional(),
-  /** Its context as its agent last reported it, after a turn (context handover spec §3.1); left out, not measured. */
-  context: ContextSchema.optional(),
-  /** Its relief by a fresh session (§3.3): asked, launched, done or failed. */
-  handover: HandoverSchema.optional(),
-  /** The session it relieves, when it is a relief. */
-  relieves: RelievesSchema.optional(),
-  /** A model change asked while the agent worked (`session.model`), applied at its next free moment; a field left out is the agent's default. */
-  modelNext: z2.object({ model: z2.string().optional(), effort: z2.string().optional() }).optional(),
-  /** The agent's own session id when Ledge chose it at launch (Claude Code `--session-id`). */
-  agentSessionId: z2.string().optional(),
-  /** OMP: the exact journal file of the conversation, what a resume names (never "the latest of the folder"). */
-  agentSessionFile: z2.string().optional(),
-  /** The agent's transcript: the latest one a hook named (it follows /clear and --resume), else the one the launch implies. */
-  transcriptPath: z2.string().optional(),
-  exitCode: z2.number().int().nullable().optional(),
-  exitedAt: z2.string().datetime().optional(),
-  lastError: z2.string().optional(),
-  source: z2.enum(["launcher", "hook_only"]),
-  /** When the session was put in the archive (session management): set, it leaves the live list and waits to be restored, resumed or deleted. */
-  archivedAt: z2.string().datetime().optional(),
-  /** When the session was last taken out of the archive: the poller's retirement clock restarts from it, not from `exitedAt`. */
-  restoredAt: z2.string().datetime().optional()
-});
-function backendOf(s) {
-  return s.backend ?? "tmux";
-}
-function isArchived(s) {
-  return s.archivedAt !== void 0;
-}
-
-// ../protocol/src/tasks.ts
-import { z as z3 } from "zod";
-var TASK_TITLE_MAX = 200;
-var TASK_TEXT_MAX = 2e4;
-var LEDGE_GIVER = "ledge";
-var TASK_OPS = ["give", "take", "pass", "done", "refuse", "cancel", "drop"];
-var TRANSMISSION_OPS = ["give", "pass", "done", "refuse", "cancel"];
-var TaskLogEntrySchema = z3.object({
-  at: z3.string(),
-  by: z3.string(),
-  what: z3.string(),
-  op: z3.enum(TASK_OPS).optional(),
-  from: z3.string().optional(),
-  to: z3.string().optional(),
-  fromName: z3.string().optional(),
-  toName: z3.string().optional(),
-  note: z3.string().optional()
-});
-var TaskSchema = z3.object({
-  id: z3.string(),
-  title: z3.string(),
-  text: z3.string().optional(),
-  giver: z3.string(),
-  giverName: z3.string(),
-  owner: z3.string(),
-  ownerName: z3.string(),
-  state: z3.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z3.string().optional(),
-  /** The live team its owner sat in when it was given (or passed), so a team's tasks can be listed. */
-  team: z3.string().optional(),
-  /** A task Ledge gave and the user put away from « À toi » once closed. */
-  seen: z3.boolean().optional(),
-  at: z3.string(),
-  updatedAt: z3.string(),
-  log: z3.array(TaskLogEntrySchema)
-});
-var handOver = (op) => TRANSMISSION_OPS.includes(op ?? "");
-function transmissions(t) {
-  return t.log.flatMap((e, index) => handOver(e.op) && e.from !== void 0 && e.to !== void 0 ? [{ index, at: e.at, op: e.op, from: e.from, to: e.to, fromName: e.fromName ?? "", toName: e.toName ?? "", ...e.note !== void 0 ? { note: e.note } : {} }] : []);
-}
-var givenByLedge = (t) => t.giver === LEDGE_GIVER;
-var taskClosed = (t) => t.state === "done" || t.state === "refused" || t.state === "dropped";
-var TaskCmdSchema = z3.object({
-  type: z3.literal("task.cmd"),
-  rid: z3.string().min(1),
-  by: z3.string().min(1),
-  op: z3.enum(["give", "take", "done", "refuse", "pass", "show", "list", "seen"]),
-  task: z3.string().min(1).max(40).optional(),
-  to: z3.string().min(1).optional(),
-  title: z3.string().min(1).max(TASK_TITLE_MAX).optional(),
-  text: z3.string().max(TASK_TEXT_MAX).optional(),
-  all: z3.boolean().optional(),
-  team: z3.string().min(1).max(40).optional(),
-  qid: z3.string().min(1).optional(),
-  row: z3.number().int().min(0).max(7).optional()
-});
-var TaskUpdatedSchema = z3.object({ type: z3.literal("task.updated"), task: TaskSchema });
-var TaskResultSchema = z3.object({
-  type: z3.literal("task.result"),
-  rid: z3.string(),
-  task: TaskSchema.optional(),
-  tasks: z3.array(TaskSchema).optional(),
-  reason: z3.string().optional()
-});
-
-// ../protocol/src/messages.ts
-import { z as z19 } from "zod";
-
-// ../protocol/src/chat.ts
-import { z as z5 } from "zod";
-
-// ../protocol/src/attachments.ts
-import { z as z4 } from "zod";
-var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
-var AttachmentIdSchema = z4.string().regex(ATTACHMENT_ID);
-var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
-var ImageMimeSchema = z4.enum(IMAGE_MIMES);
-var ATTACHMENT_MAX = 4e5;
-var ATTACHMENT_LOCAL_MAX = 2e6;
-var PREVIEW_MAX = 4e4;
-var ATTACHMENTS_MAX = 5;
-var b64Max = (bytes) => Math.ceil(bytes / 3) * 4;
-var AttachmentRefSchema = z4.object({
-  id: AttachmentIdSchema,
-  mime: ImageMimeSchema,
-  width: z4.number().int().positive(),
-  height: z4.number().int().positive(),
-  bytes: z4.number().int().positive(),
-  preview: z4.boolean()
-});
-var ImageUploadSchema = z4.object({
-  mime: ImageMimeSchema,
-  data: z4.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
-  preview: z4.object({ mime: ImageMimeSchema, data: z4.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
-});
-var AttachmentErrorReasonSchema = z4.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
-var requestId = z4.string().min(1).max(100);
-var AttachmentPutSchema = z4.object({ type: z4.literal("attachment.put"), requestId, id: z4.string().optional(), image: ImageUploadSchema });
-var AttachmentGetSchema = z4.object({ type: z4.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z4.boolean().optional(), id: z4.string().optional(), machine: z4.string().optional() });
-var AttachmentStoredSchema = z4.object({ type: z4.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
-var AttachmentDataSchema = z4.object({ type: z4.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z4.string() });
-var AttachmentErrorSchema = z4.object({ type: z4.literal("attachment.error"), requestId, reason: AttachmentErrorReasonSchema });
-
-// ../protocol/src/chat.ts
-var ChatStepSchema = z5.object({
-  kind: z5.enum(["sessions", "pane", "reply", "git", "repo"]),
-  id: z5.string().optional(),
-  name: z5.string().optional(),
-  path: z5.string().optional()
-});
-var ChatProposalSchema = z5.object({
-  cwd: z5.string().min(1),
-  project: z5.string(),
-  prompt: z5.string().optional(),
-  tool: ToolSchema,
-  launchedId: z5.string().optional(),
-  error: z5.string().optional()
-});
-var MAX_PROPOSALS = 8;
-var ChatProposalsSchema = z5.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatRelaySchema = z5.object({
-  id: z5.string().min(1),
-  name: z5.string(),
-  tool: ToolSchema,
-  text: z5.string().min(1),
-  status: z5.enum(["queued", "sent"]).optional(),
-  sentAt: z5.string().datetime().optional(),
-  error: z5.string().optional()
-});
-var ChatCloseSchema = z5.object({
-  id: z5.string().min(1),
-  name: z5.string(),
-  tool: ToolSchema,
-  closedAt: z5.string().datetime().optional(),
-  how: z5.enum(["exit", "killed"]).optional(),
-  error: z5.string().optional()
-});
-var ChatClosesSchema = z5.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
-var ChatProjectProposalSchema = z5.object({
-  name: z5.string().min(1).max(80),
-  description: z5.string().max(500).optional(),
-  repos: z5.array(z5.object({ path: z5.string().min(1).max(4096), why: z5.string().min(1).max(200) })).min(1).max(50),
-  addTo: z5.string().min(1).max(80).optional()
-});
-var ChatTeamSeatSchema = z5.object({
-  role: z5.string().min(1),
-  label: z5.string(),
-  tool: ToolSchema,
-  model: z5.string().optional(),
-  effort: z5.string().optional(),
-  autonomy: AutonomySchema.optional(),
-  name: z5.string().optional()
-});
-var ChatTeamProposalSchema = z5.object({
-  cwd: z5.string().min(1),
-  project: z5.string(),
-  projectName: z5.string().optional(),
-  name: z5.string().min(1),
-  template: z5.string().optional(),
-  seats: z5.array(ChatTeamSeatSchema).min(1).max(8),
-  teamId: z5.string().optional(),
-  launchedAt: z5.string().datetime().optional(),
-  error: z5.string().optional(),
-  savedPath: z5.string().optional()
-});
-var ChatTaskProposalSchema = z5.object({
-  to: z5.string().min(1),
-  toName: z5.string().optional(),
-  team: z5.string().optional(),
-  title: z5.string().min(1).max(200),
-  text: z5.string().max(2e4).optional(),
-  taskId: z5.string().optional(),
-  ownerName: z5.string().optional(),
-  state: z5.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  givenAt: z5.string().datetime().optional(),
-  error: z5.string().optional()
-});
-var ChatTasksSchema = z5.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
-var ChatTurnSchema = z5.object({
-  machineId: z5.string().optional(),
-  machineName: z5.string().optional(),
-  choices: z5.array(z5.object({ id: z5.string(), label: z5.string() })).optional(),
-  qid: z5.string().min(1),
-  question: z5.string(),
-  askedAt: z5.string().datetime(),
-  steps: z5.array(ChatStepSchema),
-  answer: z5.string().optional(),
-  answeredAt: z5.string().datetime().optional(),
-  error: z5.string().optional(),
-  proposal: ChatProposalSchema.optional(),
-  proposals: ChatProposalsSchema.optional(),
-  relay: ChatRelaySchema.optional(),
-  closes: ChatClosesSchema.optional(),
-  projectProposal: ChatProjectProposalSchema.optional(),
-  team: ChatTeamProposalSchema.optional(),
-  tasks: ChatTasksSchema.optional(),
-  attachments: z5.array(AttachmentRefSchema).optional()
-});
-var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
-
-// ../protocol/src/repos.ts
-import { z as z6 } from "zod";
-var ReposInspectSchema = z6.object({
-  type: z6.literal("repos.inspect"),
-  requestId: z6.string().min(1).max(100),
-  paths: z6.array(z6.string().min(1)).min(1).max(50),
-  machineId: z6.string().optional()
-});
-var RepoInfoSchema = z6.object({ path: z6.string(), exists: z6.boolean(), branch: z6.string().nullable() });
-var ReposInfoSchema = z6.object({ type: z6.literal("repos.info"), requestId: z6.string(), repos: z6.array(RepoInfoSchema) });
-
-// ../protocol/src/models.ts
-import { z as z7 } from "zod";
-var ModelIdSchema = z7.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
-var EffortSchema = z7.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
-var ModelChoiceSchema = z7.object({
-  id: ModelIdSchema,
-  label: z7.string(),
-  description: z7.string().optional(),
-  efforts: z7.array(EffortSchema).optional(),
-  defaultEffort: EffortSchema.optional(),
-  isDefault: z7.boolean().optional()
-});
-var ModelsListSchema = z7.object({
-  type: z7.literal("models.list"),
-  requestId: z7.string().min(1).max(100),
-  tool: ToolSchema,
-  machineId: z7.string().optional()
-});
-var ModelsListingSchema = z7.object({
-  type: z7.literal("models.listing"),
-  requestId: z7.string(),
-  tool: ToolSchema,
-  models: z7.array(ModelChoiceSchema),
-  error: z7.string().optional()
-});
-
-// ../protocol/src/scan.ts
-import { z as z8 } from "zod";
-var ReposScanSchema = z8.object({ type: z8.literal("repos.scan"), requestId: z8.string().min(1).max(100), machineId: z8.string().optional() });
-var FoundRepoSchema = z8.object({ path: z8.string(), branch: z8.string().nullable(), remote: z8.string().optional(), manifest: z8.string().max(200).optional() });
-var ReposFoundSchema = z8.object({ type: z8.literal("repos.found"), requestId: z8.string(), repos: z8.array(FoundRepoSchema).max(500), truncated: z8.boolean(), error: z8.string().optional() });
-
-// ../protocol/src/documents.ts
-import { z as z9 } from "zod";
-var DOCUMENT_MAX_BYTES = 1048576;
-var path = z9.string().min(1).max(4096);
-var requestId2 = z9.string().min(1);
-var DocumentReadSchema = z9.object({
-  type: z9.literal("document.read"),
-  requestId: requestId2,
-  path,
-  machineId: z9.string().optional(),
-  sessionId: z9.string().min(1).optional(),
-  basePath: path.optional()
-});
-var DocumentContentSchema = z9.object({
-  type: z9.literal("document.content"),
-  requestId: requestId2,
-  path,
-  text: z9.string(),
-  bytes: z9.number().int().nonnegative(),
-  modifiedAt: z9.string().datetime()
-});
-var DocumentErrorCodeSchema = z9.enum([
-  "not_found",
-  "not_file",
-  "unsupported_path",
-  "unsupported_type",
-  "permission_denied",
-  "too_large",
-  "invalid_utf8",
-  "ambiguous_path",
-  "session_missing",
-  "read_failed"
-]);
-var DocumentErrorSchema = z9.object({
-  type: z9.literal("document.error"),
-  requestId: requestId2,
-  path,
-  code: DocumentErrorCodeSchema
-});
-
-// ../protocol/src/routing.ts
-import { z as z10 } from "zod";
-var MachineInventorySchema = z10.object({
-  id: z10.string().min(1).max(80),
-  label: z10.string().min(1).max(120),
-  online: z10.boolean(),
-  local: z10.boolean(),
-  sessions: z10.array(z10.object({ id: z10.string(), name: z10.string(), project: z10.string(), cwd: z10.string(), topic: z10.string().optional(), state: z10.string(), readOnly: z10.boolean() })).max(500),
-  folders: z10.array(z10.object({ project: z10.string(), cwd: z10.string() })).max(100)
-});
-var RoutingContextSchema = z10.object({
-  machines: z10.array(MachineInventorySchema).min(1).max(20),
-  history: z10.array(z10.object({ question: z10.string().max(2e4), answer: z10.string().max(2e4).optional(), machineId: z10.string().optional() })).max(50)
-});
-var RouteResultSchema = z10.object({
-  /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z10.string().nullable(),
-  text: z10.string().min(1).max(2e4),
-  choices: z10.array(z10.string()).max(20).optional()
-});
-
-// ../protocol/src/ssh.ts
-import { z as z11 } from "zod";
-var SshAliasSchema = z11.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
-
-// ../protocol/src/machines.ts
-import { z as z12 } from "zod";
-var MachineIdSchema = z12.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
-var MachineSchema = z12.object({
-  id: MachineIdSchema,
-  label: z12.string().trim().min(1).max(80),
-  ssh: SshAliasSchema.optional()
-});
-var MachinesSchema = z12.array(MachineSchema).min(1).max(20).superRefine((list, ctx) => {
-  if (list[0]?.id !== "local" || list[0].ssh !== void 0) ctx.addIssue({ code: "custom", message: "the first machine is local, without ssh", path: [0] });
-  const ids = /* @__PURE__ */ new Set(), aliases = /* @__PURE__ */ new Set();
-  list.forEach((m, i) => {
-    if (i > 0 && !m.ssh) ctx.addIssue({ code: "custom", message: "a remote machine needs an ssh alias", path: [i, "ssh"] });
-    if (ids.has(m.id)) ctx.addIssue({ code: "custom", message: `duplicate id ${m.id}`, path: [i, "id"] });
-    ids.add(m.id);
-    if (m.ssh) {
-      if (aliases.has(m.ssh)) ctx.addIssue({ code: "custom", message: `duplicate ssh alias ${m.ssh}`, path: [i, "ssh"] });
-      aliases.add(m.ssh);
-    }
-  });
-});
-
-// ../protocol/src/island.ts
-import { z as z13 } from "zod";
-var IslandScaleSchema = z13.union([z13.literal("auto"), z13.literal(1), z13.literal(1.25), z13.literal(1.5), z13.literal(2)]);
-var IslandPrefsSchema = z13.object({
-  /** Shown at the top of the screen; hidden, Desktop still notifies. */
-  visible: z13.boolean(),
-  /** `primary` (whichever it is after a reconfiguration), or a monitor's id as the shell lists it (`list_monitors`: the OS
-   *  name, `#index` without one). `second`, written by older fronts, is the first monitor that is not the primary. */
-  screen: z13.string().trim().min(1).max(200),
-  position: z13.enum(["center", "left", "right"]),
-  /** A strip under a maximised window. */
-  discreet: z13.boolean(),
-  islandScale: IslandScaleSchema,
-  panelScale: IslandScaleSchema,
-  /** What the island shows besides asks and questions, which it always shows. */
-  shows: z13.object({
-    /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
-    quick: z13.boolean(),
-    /** The 6 s bubble when an agent finishes. */
-    finished: z13.boolean(),
-    /** An agent's sentence in a bubble. */
-    say: z13.boolean(),
-    /** The sub-agents next to their main agent. */
-    helpers: z13.boolean()
-  }),
-  /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
-  shortcut: z13.string().trim().min(1).max(40)
-});
-
-// ../protocol/src/projects.ts
-import { z as z14 } from "zod";
-var PROJECT_COLORS = { blue: "#3b82f6", green: "#10b981", amber: "#f59e0b", violet: "#8b5cf6", teal: "#14b8a6", pink: "#ec4899", red: "#ef4444", slate: "#64748b" };
-var ProjectColorSchema = z14.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
-var ProjectIdSchema = z14.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
-function normalizePath(raw) {
-  const p = raw.trim().replace(/\/+/g, "/");
-  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
-}
-var PathSchema = z14.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
-var RepoSchema = z14.object({ machine: MachineIdSchema, path: PathSchema });
-var ProjectSchema = z14.object({
-  id: ProjectIdSchema,
-  name: z14.string().trim().min(1).max(80),
-  color: ProjectColorSchema,
-  description: z14.string().max(500).default(""),
-  repos: z14.array(RepoSchema).max(50)
-});
-var RuleSchema = z14.object({ machine: MachineIdSchema, path: PathSchema, project: ProjectIdSchema });
-function projectsProblems(p) {
-  const out = [];
-  const ids = /* @__PURE__ */ new Set(), names = /* @__PURE__ */ new Set(), repos = /* @__PURE__ */ new Set(), rules = /* @__PURE__ */ new Set();
-  p.projects.forEach((project, i) => {
-    if (ids.has(project.id)) out.push({ code: "duplicate_id", path: ["projects", i, "id"] });
-    ids.add(project.id);
-    const name = project.name.trim().toLocaleLowerCase();
-    if (names.has(name)) out.push({ code: "duplicate_name", path: ["projects", i, "name"] });
-    names.add(name);
-    project.repos.forEach((repo, j) => {
-      const key = `${repo.machine}
-${repo.path}`;
-      if (repos.has(key)) out.push({ code: "duplicate_repo", path: ["projects", i, "repos", j] });
-      repos.add(key);
-    });
-  });
-  p.rules.forEach((rule, i) => {
-    const key = `${rule.machine}
-${rule.path}`;
-    if (rules.has(key)) out.push({ code: "duplicate_rule", path: ["rules", i] });
-    rules.add(key);
-    if (!ids.has(rule.project)) out.push({ code: "unknown_project", path: ["rules", i, "project"] });
-  });
-  return out;
-}
-var ProjectsSchema = z14.object({ projects: z14.array(ProjectSchema).max(100), rules: z14.array(RuleSchema).max(1e3) }).superRefine((p, ctx) => {
-  for (const problem of projectsProblems(p)) ctx.addIssue({ code: "custom", message: problem.code, path: problem.path });
-});
-var DEFAULT_PROJECTS = { projects: [], rules: [] };
-var under = (cwd, path2) => path2 === "/" || cwd === path2 || cwd.startsWith(`${path2}/`);
-function projectOf(session, state) {
-  const machine = session.machineId ?? "local";
-  const cwd = normalizePath(session.cwd);
-  const known = new Set(state.projects.map((p) => p.id));
-  const candidates = [
-    ...state.projects.flatMap((p) => p.repos.filter((r) => r.machine === machine).map((r) => ({ project: p.id, path: r.path, rule: false }))),
-    ...state.rules.filter((r) => r.machine === machine && known.has(r.project)).map((r) => ({ project: r.project, path: r.path, rule: true }))
-  ].filter((c) => under(cwd, c.path));
-  candidates.sort((x, y) => y.path.length - x.path.length || Number(y.rule) - Number(x.rule));
-  return candidates[0]?.project ?? null;
-}
-
-// ../protocol/src/thread.ts
-import { z as z15 } from "zod";
-var ToolStatusSchema = z15.enum(["running", "success", "failed", "unknown"]);
-var FileChangeSchema = z15.object({ path: z15.string().min(1), from: z15.string().min(1).optional(), change: z15.enum(["add", "edit", "delete", "write"]), diff: z15.string().optional() });
-var base = { id: z15.string().min(1), at: z15.string().datetime(), turn: z15.number().int().nonnegative(), helperId: z15.string().optional() };
-var ThreadItemSchema = z15.discriminatedUnion("kind", [
-  z15.object({ kind: z15.literal("prompt"), ...base, text: z15.string(), images: z15.array(AttachmentRefSchema).optional() }),
-  z15.object({ kind: z15.literal("message"), ...base, text: z15.string() }),
-  /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row; `byClose`: a question
-   *  dismissed by Ledge closing the session. */
-  z15.object({ kind: z15.literal("tool"), ...base, tool: z15.string(), label: z15.string(), input: z15.string().optional(), output: z15.string().optional(), error: z15.string().optional(), status: ToolStatusSchema, durationMs: z15.number().nonnegative().optional(), files: z15.array(FileChangeSchema).default([]), byClose: z15.literal(true).optional() }),
-  /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again;
-   *  `byClose`: denied by Ledge closing the session. */
-  z15.object({ kind: z15.literal("permission"), ...base, tool: z15.string(), text: z15.string(), decision: z15.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z15.literal(true).optional() }),
-  z15.object({ kind: z15.literal("reply"), ...base, text: z15.string() }),
-  z15.object({ kind: z15.literal("helper"), ...base, task: z15.string(), agentType: z15.string().optional(), state: z15.enum(["working", "exited"]) }),
-  /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread, `via` set when Ledge's mailbox carries it. */
-  z15.object({ kind: z15.literal("sent"), ...base, to: z15.string(), peer: z15.string().optional(), summary: z15.string().optional(), text: z15.string(), status: z15.enum(["sending", "delivered", "read", "failed"]), received: z15.string().optional(), via: z15.literal("ledge").optional() }),
-  /** A message another agent sent to this session; `from` is its from-name (else its address), `sent` the paired item's id in the peer's thread. */
-  z15.object({ kind: z15.literal("received"), ...base, from: z15.string(), peer: z15.string().optional(), text: z15.string(), sent: z15.string().optional() }),
-  /** An automated notice of the agent's harness about messages between sessions (Claude Code's `[Cross-session idle
-   *  notice]` / `[Cross-session delivery notice]`): a system event, never the user's words. `name` is the session it is
-   *  about as quoted, `peer` its Ledge session id; a delivery notice says the outcome of `count` messages to `recipients`. */
-  z15.object({
-    kind: z15.literal("notice"),
-    ...base,
-    notice: z15.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
-    /** An `other` notice from Ledge: `task`, the task a `<ledge-task>` is about; `team`, the team a `<ledge-notice team>` seated the
-     *  session in (roles spec §3.3). An older front, which knows neither, shows it as any other notice. */
-    task: z15.string().optional(),
-    team: z15.string().optional(),
-    /** A task this session handed over (`outgoing`), and how (issue #92). */
-    taskOp: z15.enum(TRANSMISSION_OPS).optional(),
-    outgoing: z15.literal(true).optional(),
-    name: z15.string().optional(),
-    peer: z15.string().optional(),
-    time: z15.string().optional(),
-    summary: z15.string().optional(),
-    status: z15.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
-    count: z15.number().int().positive().optional(),
-    recipients: z15.array(z15.string()).optional(),
-    reason: z15.string().optional(),
-    text: z15.string()
-  })
-]);
-
-// ../protocol/src/decisions.ts
-import { z as z16 } from "zod";
-var DecisionSchema = z16.enum(["accept", "deny", "always"]);
-var NOTE_MAX = 4e3;
-var NOTE_NOT_TYPED = "note_not_typed";
-var DECISION_OFFERS = {
-  claude: { always: ["permission", "diff", "plan"], note: ["permission", "diff", "plan"] },
-  codex: { always: ["permission", "diff"], note: ["permission", "diff", "plan"] },
-  cursor: { always: [], note: ["permission", "plan"] },
-  /** OMP answers its own native requests (spec 2026-10-20 §3.3): no « always », no note until those are typed. */
-  omp: { always: [], note: [] }
-};
-function offers(tool, kind, what) {
-  return DECISION_OFFERS[tool][what].includes(kind);
-}
-function cyrb53(str, seed) {
-  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
-  for (let i = 0; i < str.length; i++) {
-    const ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
-}
-function pendingKey(p) {
-  const s = JSON.stringify([p.kind, p.text, p.body ?? null, p.tool ?? null, p.options ?? null, p.optionDetails ?? null, p.helperId ?? null]);
-  return cyrb53(s, 0) + cyrb53(s, 1);
-}
-
-// ../protocol/src/mobile.ts
-import { z as z17 } from "zod";
-var DEFAULT_RELAY_URL = "https://app.kl-ledge.dev";
-var RelayUrlSchema = z17.string().transform((v, ctx) => {
-  const bad = () => {
-    ctx.addIssue({ code: z17.ZodIssueCode.custom, message: "invalid relay URL" });
-    return z17.NEVER;
-  };
-  let u;
-  try {
-    u = new URL(v.replace(/\/$/, ""));
-  } catch {
-    return bad();
-  }
-  const local = u.hostname === "localhost" || u.hostname === "127.0.0.1";
-  if (u.protocol !== "https:" && !(u.protocol === "http:" && local)) return bad();
-  if (u.username || u.password || u.pathname !== "/" || u.search || u.hash) return bad();
-  return u.origin;
-});
-var MobileConfigSchema = z17.object({ enabled: z17.boolean(), relayUrl: RelayUrlSchema });
-var MobileLinkStateSchema = z17.discriminatedUnion("state", [
-  z17.object({ state: z17.literal("off") }),
-  z17.object({ state: z17.literal("connecting") }),
-  z17.object({ state: z17.literal("online") }),
-  z17.object({ state: z17.literal("offline"), retryAt: z17.string().datetime(), error: z17.string() }),
-  z17.object({ state: z17.literal("signed_out"), reason: z17.enum(["other_pc", "session_invalid"]) }),
-  /** The mobile service did not start (a broken mobile.json, a missing key store): nothing is linked until the daemon restarts. */
-  z17.object({ state: z17.literal("unavailable"), error: z17.string().max(200) })
-]);
-var MobilePairingSchema = z17.object({
-  id: z17.string(),
-  label: z17.string(),
-  code: z17.string().nullable(),
-  expiresAt: z17.string().datetime(),
-  state: z17.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
-});
-var MobileStateSchema = z17.object({
-  enabled: z17.boolean(),
-  relayUrl: z17.string(),
-  account: z17.object({ login: z17.string(), accountId: z17.string() }).nullable(),
-  signin: z17.object({ userCode: z17.string(), verificationUri: z17.string(), expiresAt: z17.string().datetime() }).nullable(),
-  /** The last sign-in that did not end with a session; cleared by the next one. */
-  signinError: z17.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
-  link: MobileLinkStateSchema,
-  devices: z17.array(z17.object({ id: z17.string(), label: z17.string(), approvedAt: z17.string(), online: z17.boolean(), lastSeenAt: z17.string().optional() })),
-  pairings: z17.array(MobilePairingSchema)
-});
-
-// ../protocol/src/teams.ts
-import { z as z18 } from "zod";
-var RoleIdSchema = z18.string().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/);
-var ROLE_LABEL_MAX = 40;
-var ROLE_PROMPT_MAX = 8e3;
-var RoleSchema = z18.object({
-  id: RoleIdSchema,
-  label: z18.string().min(1).max(ROLE_LABEL_MAX),
-  prompt: z18.string().max(ROLE_PROMPT_MAX),
-  tool: ToolSchema.optional(),
-  model: ModelIdSchema.optional(),
-  effort: EffortSchema.optional(),
-  autonomy: AutonomySchema.optional(),
-  source: z18.enum(["repo", "home"]),
-  path: z18.string()
-});
-var DefinitionProblemSchema = z18.object({ path: z18.string(), reason: z18.string() });
-var TEAM_SEATS_MAX = 8;
-var SeatSchema = z18.object({
-  role: RoleIdSchema,
-  tool: ToolSchema.optional(),
-  model: ModelIdSchema.optional(),
-  effort: EffortSchema.optional(),
-  name: z18.string().min(1).max(40).optional()
-});
-var uniqueRoles = (seats) => new Set(seats.map((s) => s.role)).size === seats.length;
-var SeatsSchema = z18.array(SeatSchema).min(1).max(TEAM_SEATS_MAX).refine(uniqueRoles, "a role twice in one team");
-var TeamNameSchema = z18.string().trim().min(1).max(60);
-var TeamTemplateSchema = z18.object({ id: z18.string().min(1).max(64), name: TeamNameSchema, seats: SeatsSchema, source: z18.enum(["repo", "home"]), path: z18.string() });
-var TeamIdSchema = z18.string().regex(/^team-[0-9a-f]{4,8}$/);
-var TeamStateSchema = z18.enum(["active", "resting", "dissolved"]);
-var TeamSchema = z18.object({
-  id: TeamIdSchema,
-  name: TeamNameSchema,
-  template: z18.string().optional(),
-  project: z18.string().nullable(),
-  machine: z18.string(),
-  cwd: z18.string(),
-  state: TeamStateSchema,
-  seats: z18.array(z18.object({ role: RoleIdSchema, sessionId: z18.string().nullable() })).max(TEAM_SEATS_MAX * 2),
-  createdAt: z18.string(),
-  updatedAt: z18.string(),
-  restingAt: z18.string().optional(),
-  dissolvedAt: z18.string().optional()
-});
-var RolesListSchema = z18.object({ type: z18.literal("roles.list"), cwd: z18.string().min(1).optional(), requestId: z18.string().max(100).optional(), machineId: z18.string().optional() });
-var RolesListingSchema = z18.object({ type: z18.literal("roles.listing"), requestId: z18.string().optional(), roles: z18.array(RoleSchema), templates: z18.array(TeamTemplateSchema).default([]), problems: z18.array(DefinitionProblemSchema) });
-var TeamLaunchSchema = z18.object({
-  type: z18.literal("team.launch"),
-  rid: z18.string().min(1).max(100),
-  cwd: z18.string().min(1).optional(),
-  template: z18.string().min(1).max(64).optional(),
-  seats: SeatsSchema.optional(),
-  name: TeamNameSchema.optional(),
-  qid: z18.string().min(1).optional(),
-  machineId: z18.string().optional()
-});
-var TeamJoinSchema = z18.object({ type: z18.literal("team.join"), team: TeamIdSchema, session: z18.string().min(1), role: RoleIdSchema });
-var TeamLeaveSchema = z18.object({ type: z18.literal("team.leave"), team: TeamIdSchema, session: z18.string().min(1) });
-var TeamResumeSchema = z18.object({ type: z18.literal("team.resume"), team: TeamIdSchema });
-var TeamDissolveSchema = z18.object({ type: z18.literal("team.dissolve"), team: TeamIdSchema });
-var TeamSaveSchema = z18.object({ type: z18.literal("team.save"), rid: z18.string().min(1).max(100), name: TeamNameSchema, seats: SeatsSchema, qid: z18.string().min(1).optional() });
-var TeamsMessageSchema = z18.object({ type: z18.literal("teams"), teams: z18.array(TeamSchema) });
-var TeamUpdatedSchema = z18.object({ type: z18.literal("team.updated"), team: TeamSchema });
-var TeamLaunchedSchema = z18.object({ type: z18.literal("team.launched"), rid: z18.string(), team: TeamSchema });
-var TeamFailedSchema = z18.object({ type: z18.literal("team.failed"), rid: z18.string(), reason: z18.string(), team: TeamSchema.optional() });
-var TeamSavedSchema = z18.object({ type: z18.literal("team.saved"), rid: z18.string(), path: z18.string().optional(), reason: z18.string().optional() });
-
-// ../protocol/src/messages.ts
-var PROTOCOL_PORT = 47831;
-var RefusalCodeSchema = z19.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid", "attachment_missing", "attachments_not_accepted"]);
-var SessionEventSchema = z19.object({
-  name: z19.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
-  at: z19.string().datetime(),
-  source: z19.enum(["hook", "pane", "daemon"]),
-  tool: z19.string().optional(),
-  text: z19.string().optional(),
-  options: z19.array(z19.string()).optional(),
-  /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z19.array(z19.string()).optional(),
-  kind: z19.enum(["question", "permission", "plan", "diff"]).optional(),
-  /** PanePrompt: what to review in full before deciding (a plan read in the terminal), when `text` is its summary. */
-  body: z19.string().optional(),
-  exitCode: z19.number().int().nullable().optional(),
-  helperId: z19.string().optional(),
-  /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z19.string().optional(),
-  /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z19.boolean().optional(),
-  /** UserPromptSubmit: the images the prompt carried, by attachment id. */
-  attachments: z19.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
-  /** QueueUpdate: OMP's queue as it stands. */
-  queue: z19.array(z19.object({ text: z19.string(), mode: z19.enum(["steer", "follow_up"]) })).optional(),
-  /** AgentMessage: the harness's own message, its text so far (`streaming`) or whole. `messageId` is unique for the session's life. */
-  messageId: z19.string().optional(),
-  streaming: z19.boolean().optional(),
-  /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
-  requestId: z19.string().optional(),
-  questions: z19.array(AskQuestionSchema).optional(),
-  /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
-  streamed: z19.boolean().optional(),
-  /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
-  toolUseId: z19.string().optional(),
-  /** The tool's input as the harness gave it, every string capped by the hook. */
-  toolInput: z19.record(z19.string(), z19.unknown()).optional(),
-  /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z19.string().optional(),
-  durationMs: z19.number().nonnegative().optional(),
-  /** PostToolUseFailure: the harness's error message. */
-  error: z19.string().optional(),
-  /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
-  transcriptPath: z19.string().optional(),
-  /** Decided: what was chosen when the daemon knows it. */
-  decision: DecisionSchema.optional(),
-  /** Decided: the request was refused by Ledge closing the session (its interrupt keys), not by the user's answer. */
-  byClose: z19.literal(true).optional(),
-  /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
-  agentSessionId: z19.string().optional()
-});
-var RecentSchema = z19.object({ cwd: z19.string().min(1), project: z19.string().min(1), lastAt: z19.string().datetime() });
-var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z19.object({
-  version: z19.string(),
-  install: z19.enum(["npm", "git", "unknown"]),
-  systemd: z19.boolean(),
-  manual: z19.string().optional(),
-  routing: z19.boolean().optional(),
-  archive: z19.boolean().optional(),
-  /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
-  models: z19.boolean().optional(),
-  /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
-  omp: z19.boolean().optional(),
-  /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
-  modelSwitch: z19.boolean().optional(),
-  /** Takes `approval` on an OMP `session.launch` (auto mode). */
-  ompApproval: z19.boolean().optional(),
-  /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
-  home: z19.string().optional(),
-  mobile: z19.boolean().optional(),
-  /** Knows roles, teams and tasks given by Ledge (spec 2026-10-25 roles). */
-  teams: z19.boolean().optional()
-});
-var UpdateFailureSchema = z19.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z19.discriminatedUnion("type", [
-  z19.object({ type: z19.literal("chat.routed"), qid: z19.string(), result: RouteResultSchema }),
-  DocumentContentSchema,
-  DocumentErrorSchema,
-  AttachmentStoredSchema,
-  AttachmentDataSchema,
-  AttachmentErrorSchema,
-  ReposInfoSchema,
-  ReposFoundSchema,
-  ModelsListingSchema,
-  /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
-   *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
-   *  from daemons older than the auto-update. */
-  z19.object({ type: z19.literal("snapshot"), sessions: z19.array(SessionSchema), recents: z19.array(RecentSchema).optional(), launcher: z19.array(z19.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
-  z19.object({ type: z19.literal("session.updated"), session: SessionSchema }),
-  /** OMP: the instructions taken back from its queue by an interrupt that restores it; the asker puts them back in its draft. */
-  z19.object({
-    type: z19.literal("session.queue.restored"),
-    id: z19.string(),
-    texts: z19.array(z19.string()),
-    /** The same instructions with the images they carried; `imagesDropped`: some images could not be put back. */
-    entries: z19.array(z19.object({ text: z19.string(), attachments: z19.array(AttachmentIdSchema).optional() })).optional(),
-    imagesDropped: z19.boolean().optional()
-  }),
-  z19.object({ type: z19.literal("session.removed"), id: z19.string() }),
-  z19.object({ type: z19.literal("session.preview"), id: z19.string(), lines: z19.array(z19.string()) }),
-  /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
-  z19.object({ type: z19.literal("session.thread"), id: z19.string(), items: z19.array(ThreadItemSchema) }),
-  z19.object({ type: z19.literal("session.thread.item"), id: z19.string(), item: ThreadItemSchema }),
-  /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
-  z19.object({ type: z19.literal("session.launched"), id: z19.string() }),
-  /** Answer to the requester of a `session.close`, once per row closed: the session `id` and how it ended. */
-  z19.object({ type: z19.literal("session.closed"), qid: z19.string(), row: z19.number().int().min(0), id: z19.string(), how: z19.enum(["exit", "killed"]) }),
-  z19.object({ type: z19.literal("recents"), recents: z19.array(RecentSchema) }),
-  /** Answer to the requester of a `folder.list` or `folder.create`: `path` resolved (`~` expanded), `parent` null at the
-   *  root, `entries` its subfolders by name (hidden ones left out). A failure keeps the asked path and says why in `error`,
-   *  never in an `error` message, which the launch form reads as a failed launch. */
-  z19.object({
-    type: z19.literal("folder.listing"),
-    path: z19.string(),
-    parent: z19.string().nullable(),
-    entries: z19.array(z19.string()),
-    error: z19.string().optional(),
-    /** The request this answers, when it carried one. */
-    requestId: z19.string().optional(),
-    /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
-    repos: z19.array(z19.object({ name: z19.string(), branch: z19.string() })).optional()
-  }),
-  /** The chat (spec 2026-10-11 §5): what Ledge reads, its words as they come, the final text, or why it stopped; the day's turns after each snapshot. */
-  z19.object({ type: z19.literal("chat.step"), qid: z19.string(), step: ChatStepSchema }),
-  z19.object({ type: z19.literal("chat.delta"), qid: z19.string(), text: z19.string() }),
-  z19.object({ type: z19.literal("chat.done"), qid: z19.string(), text: z19.string(), at: z19.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), team: ChatTeamProposalSchema.optional(), tasks: ChatTasksSchema.optional() }),
-  z19.object({ type: z19.literal("chat.error"), qid: z19.string(), message: z19.string() }),
-  z19.object({ type: z19.literal("chat.history"), turns: z19.array(ChatTurnSchema) }),
-  /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
-  z19.object({ type: z19.literal("update.progress"), version: z19.string(), step: z19.enum(["installing", "restarting"]) }),
-  /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
-  z19.object({ type: z19.literal("update.failed"), version: z19.string(), reason: UpdateFailureSchema, detail: z19.string().optional(), command: z19.string().optional() }),
-  /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z19.object({ type: z19.literal("machines"), machines: MachinesSchema }),
-  /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
-  z19.object({ type: z19.literal("projects"), projects: ProjectsSchema }),
-  /** The island's settings shared by the local fronts; null until a front sets them (the island then sends its own). Local clients only. */
-  z19.object({ type: z19.literal("island"), prefs: IslandPrefsSchema.nullable() }),
-  /** Mobile access (lot 3), after the island in each snapshot and on every change. Local clients only. */
-  z19.object({ type: z19.literal("mobile"), state: MobileStateSchema }),
-  /** The daemon's immediate answer to a `session.message`: delivered (`accepted`), held for later (`queued`), left to Claude's own SendMessage (`native`), or refused with a `reason`. */
-  z19.object({ type: z19.literal("message.ack"), rid: z19.string(), outcome: z19.enum(["accepted", "queued", "native", "refused"]), reason: z19.string().optional() }),
-  /** The answer to a `message.read`: the body with its sender, target and time, or the refusal's `reason`. */
-  z19.object({ type: z19.literal("message.body"), id: z19.string(), from: z19.string().optional(), to: z19.string().optional(), at: z19.string().optional(), text: z19.string().optional(), reason: z19.string().optional() }),
-  TaskResultSchema,
-  SessionHandoverResultSchema,
-  ContextPrefsMessageSchema,
-  HandoverResultSchema,
-  TaskUpdatedSchema,
-  RolesListingSchema,
-  TeamsMessageSchema,
-  TeamUpdatedSchema,
-  TeamLaunchedSchema,
-  TeamFailedSchema,
-  TeamSavedSchema,
-  z19.object({
-    type: z19.literal("error"),
-    message: z19.string(),
-    id: z19.string().optional(),
-    /** Le type du message client refusé. */
-    request: z19.string().optional(),
-    /** Ce que le front doit reconnaître au-delà du texte (NOTE_NOT_TYPED) ; une chaîne libre, qu'un front plus ancien ignore. */
-    code: z19.string().optional()
-  })
-]);
-var MESSAGE_MAX = 2e4;
-var SUMMARY_MAX = 500;
-var launchRows = z19.array(z19.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var ClientMessageSchema = z19.discriminatedUnion("type", [
-  z19.object({ type: z19.literal("chat.route"), qid: z19.string().min(1).max(100), text: z19.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
-  DocumentReadSchema,
-  AttachmentPutSchema,
-  AttachmentGetSchema,
-  ReposInspectSchema,
-  ReposScanSchema,
-  ModelsListSchema,
-  /** The overlay starts a session: `cwd` is a WSL path (`~` allowed), `name` a preferred bot name (the daemon picks a
-   *  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`. */
-  z19.object({
-    type: z19.literal("session.launch"),
-    tool: ToolSchema,
-    cwd: z19.string().min(1),
-    name: z19.string().optional(),
-    prompt: z19.string().optional(),
-    continue: z19.boolean().optional(),
-    qid: z19.string().min(1).optional(),
-    /** With `qid`: the card's rows to launch (#24), indexes into the turn's `proposals`, each once; the first row without it. */
-    rows: launchRows.optional(),
-    /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
-    dirs: z19.array(z19.string().min(1)).max(20).optional(),
-    /** The agent's model and effort (#58), the agent's own default when left out; with `qid`, for every row launched. */
-    model: ModelIdSchema.optional(),
-    effort: EffortSchema.optional(),
-    /** OMP only: its approval mode, `always-ask` when left out. */
-    approval: OmpApprovalSchema.optional(),
-    /** A role (spec 2026-10-25 roles §3.4): its prompt reaches the agent at every start, its defaults fill what is left out. */
-    role: RoleIdSchema.optional(),
-    /** A live team the new session joins at once, in `role`. */
-    team: TeamIdSchema.optional(),
-    /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z19.string().optional()
-  }),
-  /** The launch form's folder browser: list a folder's subfolders (home when no `path`), or make `name` inside `parent`
-   *  and list it. Both are answered with a `folder.listing`. */
-  z19.object({
-    type: z19.literal("folder.list"),
-    path: z19.string().optional(),
-    /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z19.string().optional(),
-    /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
-    requestId: z19.string().min(1).max(100).optional()
-  }),
-  z19.object({
-    type: z19.literal("folder.create"),
-    parent: z19.string().min(1),
-    name: z19.string().min(1),
-    /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
-    machineId: z19.string().optional(),
-    requestId: z19.string().min(1).max(100).optional()
-  }),
-  /** `steer`: OMP only, redirect the turn running now instead of queueing the text after it. */
-  /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order (`selected` labels, and/or free `text`); `cancel` declines it. */
-  z19.object({ type: z19.literal("session.answer"), id: z19.string(), requestId: z19.string().min(1).max(200), answers: z19.array(z19.object({ id: z19.string(), selected: z19.array(z19.string().max(2e3)).max(100), text: z19.string().max(2e4).optional() })).max(50), cancel: z19.boolean().optional() }),
-  z19.object({ type: z19.literal("session.reply"), id: z19.string(), text: z19.string(), attachments: z19.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(), steer: z19.boolean().optional() }),
-  /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
-  z19.object({ type: z19.literal("session.relay"), qid: z19.string().min(1) }),
-  /** Takes the card's queued instruction back out of the queue. */
-  z19.object({ type: z19.literal("session.relay.cancel"), qid: z19.string().min(1) }),
-  /** The chat's close card: closes the turn's sessions, `rows` (indexes into its `closes`) or all of them. */
-  z19.object({ type: z19.literal("session.close"), qid: z19.string().min(1), rows: launchRows.optional() }),
-  /** `always` and `note` only where the harness offers them (`offers`); a note goes with `deny`, for the agent to read. */
-  z19.object({
-    type: z19.literal("session.decide"),
-    id: z19.string(),
-    decision: DecisionSchema,
-    note: z19.string().trim().min(1).max(NOTE_MAX).optional(),
-    /** The request the user saw when deciding: refused (the request changed) unless it is still the pending one. Left out by older fronts and the island.
-     *  `key` (pendingKey) covers its whole content; older fronts send kind and text only. */
-    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z19.string().max(64).optional() }).optional()
-  }),
-  z19.object({ type: z19.literal("session.focus"), id: z19.string() }),
-  z19.object({ type: z19.literal("session.kill"), id: z19.string() }),
-  /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
-  z19.object({ type: z19.literal("session.interrupt"), id: z19.string(), restoreQueue: z19.boolean().optional() }),
-  /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
-  z19.object({ type: z19.literal("session.dismiss"), id: z19.string() }),
-  /** Puts a session in the archive: it leaves the live list but is kept. */
-  z19.object({ type: z19.literal("session.archive"), id: z19.string() }),
-  /** Takes an archived session back out of the archive, as it was. */
-  z19.object({ type: z19.literal("session.restore"), id: z19.string() }),
-  /** Starts the agent again on an archived session's conversation. */
-  z19.object({ type: z19.literal("session.resume"), id: z19.string() }),
-  /** Changes a live session's model and effort (#58, lot 2), `null` for the agent's own default: the daemon restarts the
-   *  agent on the same conversation with them, at once when the session is free, else at its next free moment. */
-  z19.object({ type: z19.literal("session.model"), id: z19.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
-  /** Deletes a session for good, archived or not. */
-  z19.object({ type: z19.literal("session.delete"), id: z19.string() }),
-  /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
-  z19.object({ type: z19.literal("session.rename"), id: z19.string(), topic: z19.string().max(500) }),
-  z19.object({ type: z19.literal("session.thread"), id: z19.string() }),
-  z19.object({ type: z19.literal("session.register"), session: SessionSchema }),
-  /** `agent` and `cwd` describe the session when the daemon does not know it yet (a hook from an agent started without ledge). */
-  z19.object({ type: z19.literal("session.event"), id: z19.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z19.string().optional() }),
-  z19.object({ type: z19.literal("session.unregister"), id: z19.string(), exitCode: z19.number().int().nullable() }),
-  z19.object({ type: z19.literal("snapshot.request") }),
-  z19.object({ type: z19.literal("chat.ask"), qid: z19.string().min(1), text: z19.string(), images: z19.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
-  z19.object({ type: z19.literal("chat.cancel"), qid: z19.string().min(1) }),
-  /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
-  z19.object({ type: z19.literal("chat.reset") }),
-  /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
-  z19.object({ type: z19.literal("update.daemon"), version: z19.string().regex(SEMVER) }),
-  /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
-  z19.object({ type: z19.literal("machines.set"), machines: MachinesSchema }),
-  /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
-  z19.object({ type: z19.literal("projects.set"), projects: ProjectsSchema }),
-  /** Replaces the island's settings as a whole; refused unless valid. */
-  z19.object({ type: z19.literal("island.set"), prefs: IslandPrefsSchema }),
-  /** Mobile access (lot 3), local fronts only. A changed `relayUrl` drops the relay session. */
-  z19.object({ type: z19.literal("mobile.set"), enabled: z19.boolean(), relayUrl: RelayUrlSchema }),
-  z19.object({ type: z19.literal("mobile.signin") }),
-  z19.object({ type: z19.literal("mobile.signin.cancel") }),
-  z19.object({ type: z19.literal("mobile.signout") }),
-  /** While the link is offline: try again now. */
-  z19.object({ type: z19.literal("mobile.retry") }),
-  z19.object({ type: z19.literal("mobile.pairing.approve"), id: z19.string().min(1).max(100) }),
-  z19.object({ type: z19.literal("mobile.pairing.deny"), id: z19.string().min(1).max(100) }),
-  /** `id`: the device's fingerprint. */
-  z19.object({ type: z19.literal("mobile.device.revoke"), id: z19.string().min(1).max(100) }),
-  /** One session writing to another by Ledge name (`to` may end in ` [ref]`); `intercept` (the Claude hook): answer `native` unless `to` is a live non-Claude session. */
-  z19.object({ type: z19.literal("session.message"), rid: z19.string().min(1), from: z19.string().min(1), to: z19.string().min(1), text: z19.string().min(1).max(MESSAGE_MAX), summary: z19.string().max(SUMMARY_MAX).optional(), intercept: z19.boolean().optional() }),
-  /** `ledge read <id>`: a message's whole body, for its receiver or its sender (`by`, a session id). */
-  z19.object({ type: z19.literal("message.read"), id: z19.string().min(1).max(40), by: z19.string().min(1) }),
-  TaskCmdSchema,
-  SessionHandoverSchema,
-  ContextSetSchema,
-  HandoverBriefSchema,
-  HandoverShowSchema,
-  RolesListSchema,
-  TeamLaunchSchema,
-  TeamJoinSchema,
-  TeamLeaveSchema,
-  TeamResumeSchema,
-  TeamDissolveSchema,
-  TeamSaveSchema
-]);
-function parseClientMessage(raw) {
-  return ClientMessageSchema.parse(raw);
-}
-function parseServerMessage(raw) {
-  return ServerMessageSchema.parse(raw);
-}
-
-// ../protocol/src/names.ts
-var NAMES = [
-  "Otto",
-  "Pim",
-  "Nova",
-  "Bix",
-  "Lu",
-  "Max",
-  "Ida",
-  "Rex",
-  "Zoe",
-  "Kit",
-  "Ari",
-  "Bo",
-  "Cal",
-  "Dee",
-  "Eli",
-  "Fay",
-  "Gus",
-  "Hal",
-  "Ivy",
-  "Jax",
-  "Kai",
-  "Lio",
-  "Mo",
-  "Nia",
-  "Oz",
-  "Pax",
-  "Quin",
-  "Rae",
-  "Sol",
-  "Tad",
-  "Uma",
-  "Vic",
-  "Wyn",
-  "Xen",
-  "Yan",
-  "Zia",
-  "Abe",
-  "Bea",
-  "Cy",
-  "Dot",
-  "Eva",
-  "Fin",
-  "Gil",
-  "Hen",
-  "Iro",
-  "Jo",
-  "Kip",
-  "Lex",
-  "Mia",
-  "Ned",
-  "Ola",
-  "Pat",
-  "Rio",
-  "Sam",
-  "Tia",
-  "Ulf",
-  "Val",
-  "Wes",
-  "Yui",
-  "Zed",
-  "Ash",
-  "Bry",
-  "Cleo",
-  "Dax"
-];
-var cap = (s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
-function pickName(taken, preferred) {
-  const used = new Set(taken);
-  const free = (n) => !used.has(n);
-  const wanted = preferred?.trim();
-  if (wanted) {
-    const base2 = cap(wanted);
-    if (free(base2)) return base2;
-    for (let i = 2; ; i++) if (free(`${base2}-${i}`)) return `${base2}-${i}`;
-  }
-  const first = NAMES.find(free);
-  if (first) return first;
-  for (let i = 2; ; i++) if (free(`${NAMES[0]}-${i}`)) return `${NAMES[0]}-${i}`;
-}
-
-// ../protocol/src/proposal.ts
-import { z as z20 } from "zod";
-var ProposalBlockSchema = z20.object({ cwd: z20.string().trim().min(1), prompt: z20.string().optional() });
-var RelayBlockSchema = z20.object({ session: z20.string().trim().min(1), text: z20.string().trim().min(1) });
-var ProjectBlockSchema = z20.object({
-  name: z20.string().trim().min(1).max(80),
-  description: z20.string().max(500).optional(),
-  repos: z20.array(z20.object({ path: z20.string().min(1).max(4096), why: z20.string().trim().min(1).max(200) })).min(1).max(50),
-  addTo: z20.string().trim().max(80).optional()
-});
-var CloseBlockSchema = z20.object({ session: z20.string().trim().min(1) });
-var TeamBlockSchema = z20.object({
-  cwd: z20.string().trim().min(1),
-  template: z20.string().trim().min(1).max(64).optional(),
-  name: z20.string().trim().min(1).max(60).optional(),
-  seats: z20.array(z20.object({ role: z20.string().trim().min(1).max(40), tool: z20.enum(["claude", "codex", "cursor", "omp"]).optional(), model: z20.string().max(200).optional(), effort: z20.string().max(20).optional(), name: z20.string().max(40).optional() })).min(1).max(8).optional()
-}).refine((b) => !!b.template || !!b.seats?.length, "a template or seats");
-var TaskBlockSchema = z20.object({
-  to: z20.string().trim().min(1).max(80),
-  team: z20.string().trim().max(40).optional(),
-  title: z20.string().trim().min(1).max(200),
-  text: z20.string().max(2e4).optional()
-});
-var BLOCK = /```ledge-(session|relay|project|close|team|task)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
-function extractProposal(answer) {
-  const found = [];
-  const text = answer.replace(BLOCK, (_m, kind, body) => {
-    found.push({ kind, raw: body.trim() });
-    return "";
-  });
-  const last = found.at(-1);
-  return last ? { text: text.replace(/\n{3,}/g, "\n\n").trim(), kind: last.kind, raw: last.raw, blocks: found } : { text: answer, kind: null, raw: null, blocks: [] };
-}
-function parseProposalBlock(raw) {
-  try {
-    const r = ProposalBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseRelayBlock(raw) {
-  try {
-    const r = RelayBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseCloseBlock(raw) {
-  try {
-    const r = CloseBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseTeamBlock(raw) {
-  try {
-    const r = TeamBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseTaskBlock(raw) {
-  try {
-    const r = TaskBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseProjectBlock(raw) {
-  try {
-    const r = ProjectBlockSchema.safeParse(JSON.parse(raw));
-    return r.success ? r.data : null;
-  } catch {
-    return null;
-  }
-}
-
-// ../protocol/src/topic.ts
-var TOPIC_MAX = 80;
-function cleanTopic(text) {
-  const line = text.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0) ?? "";
-  const flat = line.replace(/\s+/g, " ");
-  return flat.length > TOPIC_MAX ? `${flat.slice(0, TOPIC_MAX - 1).trimEnd()}\u2026` : flat;
-}
-function sessionTitle(s) {
-  return `${s.name} \xB7 ${s.topic || s.project}`;
-}
-
-// ../protocol/src/relay.ts
-import { z as z21 } from "zod";
-var SEALED_MAX = 1048576;
-var RelayPeerSchema = z21.union([z21.literal("pc"), z21.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
-var RelayClientMessageSchema = z21.object({
-  type: z21.literal("send"),
-  to: RelayPeerSchema,
-  body: z21.string().max(SEALED_MAX)
-});
-var RelayServerMessageSchema = z21.discriminatedUnion("type", [
-  z21.object({ type: z21.literal("welcome"), accountId: z21.string(), self: RelayPeerSchema, online: z21.array(RelayPeerSchema) }),
-  z21.object({ type: z21.literal("deliver"), from: RelayPeerSchema, body: z21.string() }),
-  z21.object({ type: z21.literal("presence"), peer: RelayPeerSchema, online: z21.boolean() }),
-  /**
-   * A frame was refused; `to` names the target when it is known.
-   * Contract: an error concerning a sealed body (`offline`, `too_large`, or a socket closed with 4008
-   * `rate_limited`) means that body was not delivered, so the sequence on that channel is lost: the
-   * sender must re-handshake with that peer before sending to it again.
-   */
-  z21.object({
-    type: z21.literal("error"),
-    code: z21.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
-    to: RelayPeerSchema.optional()
-  })
-]);
-var PAIR_LABEL_MAX = 40;
-var KeyB64 = z21.string().regex(/^[A-Za-z0-9_-]{87}$/);
-var Nonce = z21.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var Fingerprint = z21.string().regex(/^[A-Za-z0-9_-]{22}$/);
-var SealedFrameSchema = z21.discriminatedUnion("k", [
-  /** `e` is the ephemeral key, `f` the fingerprint of the sender's static key. */
-  z21.object({ k: z21.literal("hello"), e: KeyB64, f: Fingerprint }),
-  z21.object({ k: z21.literal("msg"), s: z21.string() }),
-  z21.object({ k: z21.literal("pair_commit"), c: Nonce, label: z21.string().trim().min(1).max(PAIR_LABEL_MAX) }),
-  z21.object({ k: z21.literal("pair_offer"), pc: KeyB64, n: Nonce }),
-  z21.object({ k: z21.literal("pair_reveal"), d: KeyB64, n: Nonce }),
-  z21.object({ k: z21.literal("pair_ok") }),
-  z21.object({ k: z21.literal("pair_no") }),
-  z21.object({ k: z21.literal("denied") }),
-  z21.object({ k: z21.literal("rekey") })
-]);
-
-// ../protocol/src/relayAuth.ts
-import { z as z22 } from "zod";
-var RELAY_CLOSE_SIGNED_OUT = 4001;
-var DeviceStartResponseSchema = z22.object({
-  deviceCode: z22.string().min(1),
-  userCode: z22.string().min(1),
-  verificationUri: z22.string().min(1),
-  expiresIn: z22.number().int().positive(),
-  interval: z22.number().int().positive()
-});
-var DevicePollResponseSchema = z22.discriminatedUnion("status", [
-  z22.object({ status: z22.literal("pending") }),
-  z22.object({ status: z22.literal("slow_down"), interval: z22.number().int().positive() }),
-  /** `token` is the relay session token, shown this once only. */
-  z22.object({ status: z22.literal("ok"), token: z22.string().min(1), accountId: z22.string().min(1), login: z22.string().min(1) }),
-  z22.object({ status: z22.literal("expired") }),
-  z22.object({ status: z22.literal("denied") }),
-  z22.object({ status: z22.literal("not_allowed") })
-]);
-var DeviceRevokeResponseSchema = z22.object({ revoked: z22.number().int().min(0) });
-var MeResponseSchema = z22.object({
-  accountId: z22.string().min(1),
-  login: z22.string().min(1),
-  peer: RelayPeerSchema,
-  kind: z22.enum(["pc", "device"])
-});
-
-// ../protocol/src/phone.ts
-import { z as z24 } from "zod";
-
-// ../protocol/src/push.ts
-import { z as z23 } from "zod";
-var B64U = z23.string().regex(/^[A-Za-z0-9_-]*$/);
-var PUSH_HOSTS = ["*.push.apple.com", "fcm.googleapis.com", "updates.push.services.mozilla.com", "*.notify.windows.com"];
-function pushEndpointAllowed(url) {
-  let u;
-  try {
-    u = new URL(url);
-  } catch {
-    return false;
-  }
-  if (u.protocol !== "https:" || u.port !== "" || u.username !== "" || u.password !== "") return false;
-  const host = u.hostname.toLowerCase();
-  return PUSH_HOSTS.some((h) => {
-    if (!h.startsWith("*.")) return host === h;
-    const suffix = h.slice(1);
-    return host.length > suffix.length && host.endsWith(suffix);
-  });
-}
-var PushSendSchema = z23.object({
-  endpoint: z23.string().url().max(1024),
-  body: B64U.max(5462),
-  ttl: z23.number().int().min(0).max(86400),
-  urgency: z23.enum(["normal", "high"]),
-  topic: z23.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
-});
-var PushSendResultSchema = z23.object({
-  result: z23.enum(["sent", "gone", "failed"]),
-  status: z23.number().int().optional()
-});
-var PushSubscriptionSchema = z23.object({
-  endpoint: z23.string().url().max(1024).refine(pushEndpointAllowed),
-  keys: z23.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
-});
-var PushPayloadSchema = z23.object({
-  v: z23.literal(1),
-  kind: z23.enum(["request", "question", "finished", "chat"]),
-  title: z23.string().max(80),
-  body: z23.string().max(120),
-  url: z23.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
-  badge: z23.number().int().min(0).max(999),
-  tag: z23.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
-});
-
-// ../protocol/src/phone.ts
-var PHONE_PROTOCOL = 1;
-var PAD_TIERS = [1024, 4096, 16384, 65536, 262144, 655360];
-var PLAIN_MAX = 655360;
-var utf8 = new TextEncoder();
-function padPlain(json) {
-  const bytes = utf8.encode(json).length;
-  if (bytes > PLAIN_MAX) return null;
-  const tier = PAD_TIERS.find((t) => t >= bytes);
-  if (tier === void 0) return null;
-  return json + " ".repeat(tier - bytes);
-}
-var THREAD_ITEMS_MAX = 200;
-var THREAD_BUDGET = 524288;
-var THREAD_TEXT_MAX = 8192;
-var TOOL_TEXT_MAX = 2048;
-var PENDING_BODY_MAX = 65536;
-var SNAPSHOT_BODY_MAX = 2048;
-var RiskSchema = z24.enum(["low", "high"]);
-var RiskReasonSchema = z24.enum(["question", "read_only_command", "edit_inside_folder", "pushes", "destroys", "deploys", "publishes", "pipes_to_shell", "network", "writes_outside_folder", "sensitive_path", "unsafe_flag", "shell_syntax", "script", "plan", "unknown"]);
-var OperationIdSchema = z24.string().uuid();
-var OperationStatusSchema = z24.enum(["received", "applied", "rejected", "failed"]);
-var OperationReasonSchema = z24.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired"]);
-var CapabilitiesSchema = z24.object({
-  /** A question can be answered in free text. */
-  freeTextAnswer: z24.boolean(),
-  /** The session's accept/deny can be typed; absent = true. */
-  decide: z24.boolean().optional(),
-  /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z24.boolean().optional()
-});
-var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
-var CapabilitiesByToolSchema = z24.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
-var PhonePendingSchema = PendingSchema.extend({ key: z24.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z24.literal(true).optional() });
-var PhoneSessionSchema = SessionSchema.pick({
-  id: true,
-  name: true,
-  tool: true,
-  project: true,
-  title: true,
-  topic: true,
-  repo: true,
-  branch: true,
-  worktree: true,
-  state: true,
-  helpers: true,
-  lastReply: true,
-  startedAt: true,
-  lastActivityAt: true,
-  /** Its role and its live team (ledge home spec §2.4): the agents screen groups a project's sessions by table. */
-  role: true,
-  roleLabel: true,
-  team: true,
-  /** Its context and its relief (context handover spec §3.2): the phone shows the gauge; the relief is started from the PC. */
-  context: true,
-  relieves: true
-}).extend({ pending: PhonePendingSchema.optional(), unread: z24.boolean(), handover: z24.object({ state: HandoverStateSchema, toName: z24.string().max(80).optional() }).strict().optional() });
-var B64U2 = z24.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z24.object({
-  id: B64U2.max(1366),
-  publicKey: B64U2.max(2048),
-  alg: z24.union([z24.literal(-7), z24.literal(-257)]),
-  clientDataJSON: B64U2.max(4096),
-  authenticatorData: B64U2.max(4096),
-  transports: z24.array(z24.string().max(20)).max(8).optional()
-});
-var AssertionSchema = z24.object({
-  id: B64U2.max(1366),
-  clientDataJSON: B64U2.max(4096),
-  authenticatorData: B64U2.max(4096),
-  signature: B64U2.max(1024)
-});
-var ConfirmPurposeSchema = z24.enum(["register", "decide", "launch", "close"]);
-var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z24.object({
-  project: z24.string().max(80),
-  tool: ToolSchema,
-  prompt: z24.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z24.string().optional(),
-  failed: z24.literal(true).optional()
-}).strict();
-var PhoneChatRelaySchema = z24.object({
-  id: z24.string().min(1),
-  name: z24.string(),
-  tool: ToolSchema,
-  text: z24.string().max(TOOL_TEXT_MAX),
-  status: z24.enum(["queued", "sent"]).optional(),
-  sentAt: z24.string().datetime().optional(),
-  failed: z24.literal(true).optional()
-}).strict();
-var PhoneChatCloseSchema = z24.object({
-  id: z24.string().min(1),
-  name: z24.string(),
-  tool: ToolSchema,
-  how: z24.enum(["exit", "killed"]).optional(),
-  closedAt: z24.string().datetime().optional(),
-  failed: z24.literal(true).optional()
-}).strict();
-var PhoneChatTeamSchema = z24.object({
-  project: z24.string().max(80),
-  name: z24.string().max(60),
-  template: z24.string().max(64).optional(),
-  seats: z24.array(z24.object({ role: z24.string().max(40), label: z24.string().max(40), tool: ToolSchema, model: z24.string().max(200).optional(), effort: z24.string().max(20).optional(), autonomy: AutonomySchema.optional() }).strict()).min(1).max(8),
-  teamId: z24.string().max(40).optional(),
-  launchedAt: z24.string().datetime().optional(),
-  failed: z24.literal(true).optional()
-}).strict();
-var PhoneChatTaskSchema = z24.object({
-  to: z24.string().max(80),
-  toName: z24.string().max(80).optional(),
-  title: z24.string().max(200),
-  text: z24.string().max(TOOL_TEXT_MAX).optional(),
-  taskId: z24.string().max(40).optional(),
-  ownerName: z24.string().max(80).optional(),
-  state: z24.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  failed: z24.literal(true).optional()
-}).strict();
-var PhoneTeamSchema = z24.object({
-  id: z24.string().max(40),
-  name: z24.string().max(60),
-  project: z24.string().max(80).nullable(),
-  state: z24.enum(["active", "resting"]),
-  seats: z24.array(z24.object({ role: z24.string().max(40), sessionId: z24.string().max(100).nullable() }).strict()).max(16),
-  done: z24.number().int().min(0),
-  given: z24.number().int().min(0)
-}).strict();
-var PhoneTaskSchema = z24.object({
-  id: z24.string().max(40),
-  title: z24.string().max(200),
-  owner: z24.string().max(100),
-  ownerName: z24.string().max(80),
-  ownerRole: z24.string().max(40).optional(),
-  team: z24.string().max(40).optional(),
-  teamName: z24.string().max(60).optional(),
-  state: z24.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z24.string().max(TOOL_TEXT_MAX).optional(),
-  cut: z24.literal(true).optional(),
-  at: z24.string(),
-  updatedAt: z24.string(),
-  seen: z24.literal(true).optional()
-}).strict();
-var ChatErrorCodeSchema = z24.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z24.object({
-  qid: OperationIdSchema,
-  question: z24.string().max(MESSAGE_MAX),
-  askedAt: z24.string().datetime(),
-  steps: z24.array(PhoneChatStepSchema).max(50),
-  answer: z24.string().max(THREAD_TEXT_MAX).optional(),
-  answeredAt: z24.string().datetime().optional(),
-  error: ChatErrorCodeSchema.optional(),
-  proposals: z24.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
-  relay: PhoneChatRelaySchema.optional(),
-  closes: z24.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
-  cut: z24.literal(true).optional(),
-  team: PhoneChatTeamSchema.optional(),
-  tasks: z24.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
-  attachments: z24.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
-}).strict();
-var CHAT_HISTORY_BUDGET = 393216;
-var sessionId = z24.string().min(1).max(100);
-var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z24.string().min(1).max(64) });
-var CardRowsSchema = z24.array(z24.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var PhoneClientMessageSchema = z24.discriminatedUnion("type", [
-  z24.object({ type: z24.literal("snapshot.request") }),
-  z24.object({ type: z24.literal("session.thread"), id: sessionId }),
-  /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
-  z24.object({ type: z24.literal("session.pending"), id: sessionId }),
-  /** The session whose terminal the phone shows; null when it shows none. */
-  z24.object({ type: z24.literal("session.watch"), id: sessionId.nullable() }),
-  z24.object({ type: z24.literal("session.read"), id: sessionId, at: z24.string().datetime() }),
-  /** Asks for a challenge. One object for both purposes: the gateway refuses a `decide` without `id` and `expect`. */
-  z24.object({ type: z24.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
-  z24.object({ type: z24.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z24.object({
-    type: z24.literal("session.decide"),
-    op: OperationIdSchema,
-    id: sessionId,
-    decision: DecisionSchema,
-    note: z24.string().trim().min(1).max(NOTE_MAX).optional(),
-    /** The request the phone showed: refused unless it is still the pending one. */
-    expect: PhoneExpectSchema,
-    /** The device check over the challenge of `confirm.prepare`; required by the daemon for a high-risk accept. */
-    assertion: AssertionSchema.optional()
-  }),
-  z24.object({
-    type: z24.literal("session.reply"),
-    op: OperationIdSchema,
-    id: sessionId,
-    text: z24.string().max(MESSAGE_MAX),
-    attachments: z24.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
-    /** The request the reply answers, or null when the phone showed none: refused if the session's request is no longer that one. */
-    expect: PhoneExpectSchema.nullable(),
-    assertion: AssertionSchema.optional()
-  }),
-  /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order; `cancel` declines it. Bounds as the local `session.answer`. */
-  z24.object({
-    type: z24.literal("session.answer"),
-    op: OperationIdSchema,
-    id: sessionId,
-    requestId: z24.string().min(1).max(200),
-    answers: z24.array(z24.object({ id: z24.string().max(200), selected: z24.array(z24.string().max(2e3)).max(100), text: z24.string().max(2e4).optional() })).max(50),
-    cancel: z24.literal(true).optional(),
-    expect: PhoneExpectSchema
-  }),
-  z24.object({ type: z24.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
-  /** The phone drops its passkey from the daemon. */
-  z24.object({ type: z24.literal("device.forget"), op: OperationIdSchema }),
-  /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z24.object({ type: z24.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
-  z24.object({ type: z24.literal("push.unsubscribe"), op: OperationIdSchema }),
-  /** The phone's own chat with Ledge. */
-  z24.object({ type: z24.literal("chat.ask"), qid: OperationIdSchema, text: z24.string().trim().max(MESSAGE_MAX), attachments: z24.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
-  z24.object({ type: z24.literal("chat.cancel"), qid: OperationIdSchema }),
-  z24.object({ type: z24.literal("chat.reset") }),
-  z24.object({ type: z24.literal("chat.history") }),
-  /** An image to store, sent alone before the message that names it; no `id`, and at most `ATTACHMENT_MAX` bytes. */
-  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z24.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
-  AttachmentGetSchema.pick({ type: true, requestId: true, attachment: true, preview: true }),
-  z24.object({ type: z24.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
-  z24.object({ type: z24.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
-  z24.object({ type: z24.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
-  /** The turn's team card (roles spec §3.8): launched like a session card, with the device check (purpose `launch`, the turn). */
-  z24.object({ type: z24.literal("chat.team"), op: OperationIdSchema, qid: OperationIdSchema, assertion: AssertionSchema.optional() }),
-  /** A row of the turn's task card: given by Ledge. */
-  z24.object({ type: z24.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z24.number().int().min(0).max(MAX_PROPOSALS - 1) }),
-  /** « Reprendre » a resting team. */
-  z24.object({ type: z24.literal("team.resume"), op: OperationIdSchema, team: z24.string().min(1).max(40) }),
-  /** Puts a closed task Ledge gave away from « À traiter ». */
-  z24.object({ type: z24.literal("task.seen"), op: OperationIdSchema, task: z24.string().min(1).max(40) }),
-  /** Whether the phone's app is in front: a device that is visible gets no push. */
-  z24.object({ type: z24.literal("presence"), visible: z24.boolean() })
-]);
-var PhoneServerMessageSchema = z24.discriminatedUnion("type", [
-  z24.object({ type: z24.literal("snapshot"), protocol: z24.literal(PHONE_PROTOCOL), sessions: z24.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z24.object({ version: z24.string(), name: z24.string().max(40), boot: z24.string().uuid().optional() }), device: z24.object({ confirm: z24.boolean(), push: z24.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z24.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
-  z24.object({ type: z24.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z24.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z24.number().int().positive() }),
-  z24.object({ type: z24.literal("session.updated"), session: PhoneSessionSchema }),
-  z24.object({ type: z24.literal("session.removed"), id: z24.string() }),
-  /** `pending.cut` is set when even this body was shortened. */
-  z24.object({ type: z24.literal("session.pending"), id: z24.string(), pending: PhonePendingSchema }),
-  z24.object({ type: z24.literal("session.preview"), id: z24.string(), lines: z24.array(z24.string()) }),
-  /** `cut`: the ids of the items shortened; `more`: older items were left out. */
-  z24.object({ type: z24.literal("session.thread"), id: z24.string(), items: z24.array(ThreadItemSchema), cut: z24.array(z24.string()), more: z24.boolean() }),
-  z24.object({ type: z24.literal("session.thread.item"), id: z24.string(), item: ThreadItemSchema, cut: z24.literal(true).optional() }),
-  z24.object({ type: z24.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
-  z24.object({ type: z24.literal("chat.history"), turns: z24.array(PhoneChatTurnSchema).max(50) }),
-  z24.object({ type: z24.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
-  /** The whole text so far, not an increment. */
-  z24.object({ type: z24.literal("chat.delta"), qid: OperationIdSchema, text: z24.string().max(THREAD_TEXT_MAX) }),
-  z24.object({ type: z24.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
-  z24.object({ type: z24.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
-  /** The live teams, after each snapshot and on every change. */
-  z24.object({ type: z24.literal("teams"), teams: z24.array(PhoneTeamSchema).max(50) }),
-  /** The tasks Ledge gave, open or closed lately, after each snapshot; then each change. */
-  z24.object({ type: z24.literal("tasks"), tasks: z24.array(PhoneTaskSchema).max(200) }),
-  z24.object({ type: z24.literal("task.updated"), task: PhoneTaskSchema }),
-  AttachmentStoredSchema,
-  AttachmentDataSchema,
-  AttachmentErrorSchema,
-  /** Never carries free text. */
-  z24.object({ type: z24.literal("error"), code: z24.enum(["invalid", "unknown_session", "too_large"]), request: z24.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 {
-  ATTACHMENT_ID,
-  ATTACHMENT_MAX,
-  ATTACHMENT_LOCAL_MAX,
-  PREVIEW_MAX,
-  ATTACHMENTS_MAX,
-  AttachmentRefSchema,
-  CONTEXT_NEAR,
-  CONTEXT_NEAR_MIN,
-  CONTEXT_NEAR_MAX,
-  ContextPrefsSchema,
-  contextNear,
-  BRIEF_MAX,
-  ToolSchema,
-  SessionSchema,
-  backendOf,
-  isArchived,
-  MAX_PROPOSALS,
-  ChatTurnSchema,
-  proposalRows,
-  NOTE_MAX,
-  NOTE_NOT_TYPED,
-  offers,
-  pendingKey,
-  DOCUMENT_MAX_BYTES,
-  SshAliasSchema,
-  MachinesSchema,
-  IslandPrefsSchema,
-  PROJECT_COLORS,
-  ProjectsSchema,
-  DEFAULT_PROJECTS,
-  projectOf,
-  ModelIdSchema,
-  EffortSchema,
-  RouteResultSchema,
-  TASK_TITLE_MAX,
-  TASK_TEXT_MAX,
-  LEDGE_GIVER,
-  transmissions,
-  givenByLedge,
-  taskClosed,
-  DEFAULT_RELAY_URL,
-  MobileConfigSchema,
-  ROLE_LABEL_MAX,
-  ROLE_PROMPT_MAX,
-  RoleSchema,
-  SeatsSchema,
-  TeamNameSchema,
-  TeamSchema,
-  PROTOCOL_PORT,
-  RefusalCodeSchema,
-  RecentSchema,
-  MESSAGE_MAX,
-  SUMMARY_MAX,
-  parseClientMessage,
-  parseServerMessage,
-  NAMES,
-  pickName,
-  extractProposal,
-  parseProposalBlock,
-  parseRelayBlock,
-  parseCloseBlock,
-  parseTeamBlock,
-  parseTaskBlock,
-  parseProjectBlock,
-  TOPIC_MAX,
-  cleanTopic,
-  sessionTitle,
-  RelayServerMessageSchema,
-  PAIR_LABEL_MAX,
-  SealedFrameSchema,
-  RELAY_CLOSE_SIGNED_OUT,
-  DeviceStartResponseSchema,
-  DevicePollResponseSchema,
-  pushEndpointAllowed,
-  PushSendResultSchema,
-  PushPayloadSchema,
-  PHONE_PROTOCOL,
-  padPlain,
-  THREAD_ITEMS_MAX,
-  THREAD_BUDGET,
-  THREAD_TEXT_MAX,
-  TOOL_TEXT_MAX,
-  PENDING_BODY_MAX,
-  SNAPSHOT_BODY_MAX,
-  OperationIdSchema,
-  UNTYPABLE,
-  CHAT_HISTORY_BUDGET,
-  PhoneClientMessageSchema,
-  hostAllowed,
-  requestAuthorized,
-  selectDaemonProtocol,
-  ensureDaemonToken,
-  readDaemonToken
-};