@paradow/ledge 0.21.0 → 0.22.1

package/dist/cli/chunk-ARB4BKZJ.js

@@ -0,0 +1,2302 @@
+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"]);
+function autonomyArgs(tool, autonomy) {
+  if (!autonomy || autonomy === "ask") return [];
+  switch (tool) {
+    case "claude":
+      return ["--permission-mode", autonomy === "edits" ? "acceptEdits" : "auto"];
+    case "codex":
+      return autonomy === "edits" ? ["--ask-for-approval", "on-request"] : ["--ask-for-approval", "never", "--sandbox", "workspace-write"];
+    case "cursor":
+      return autonomy === "auto" ? ["--force"] : [];
+    case "omp":
+      return [];
+  }
+}
+function ompApprovalFor(autonomy) {
+  return autonomy === "auto" ? "yolo" : autonomy ? "always-ask" : void 0;
+}
+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/teams.ts
+import { z as z4 } from "zod";
+
+// ../protocol/src/models.ts
+import { z as z3 } from "zod";
+var ModelIdSchema = z3.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/, "not a model id");
+var EffortSchema = z3.string().min(1).max(20).regex(/^[a-z]+$/, "not an effort");
+var ModelChoiceSchema = z3.object({
+  id: ModelIdSchema,
+  label: z3.string(),
+  description: z3.string().optional(),
+  efforts: z3.array(EffortSchema).optional(),
+  defaultEffort: EffortSchema.optional(),
+  isDefault: z3.boolean().optional()
+});
+var ModelsListSchema = z3.object({
+  type: z3.literal("models.list"),
+  requestId: z3.string().min(1).max(100),
+  tool: ToolSchema,
+  machineId: z3.string().optional()
+});
+var ModelsListingSchema = z3.object({
+  type: z3.literal("models.listing"),
+  requestId: z3.string(),
+  tool: ToolSchema,
+  models: z3.array(ModelChoiceSchema),
+  error: z3.string().optional()
+});
+
+// ../protocol/src/teams.ts
+var RoleIdSchema = z4.string().regex(/^[a-z0-9][a-z0-9_-]{0,39}$/);
+var ROLE_LABEL_MAX = 40;
+var ROLE_PROMPT_MAX = 8e3;
+var RoleSchema = z4.object({
+  id: RoleIdSchema,
+  label: z4.string().min(1).max(ROLE_LABEL_MAX),
+  prompt: z4.string().max(ROLE_PROMPT_MAX),
+  tool: ToolSchema.optional(),
+  model: ModelIdSchema.optional(),
+  effort: EffortSchema.optional(),
+  autonomy: AutonomySchema.optional(),
+  source: z4.enum(["repo", "home"]),
+  path: z4.string(),
+  shadows: z4.string().optional()
+});
+var DefinitionProblemSchema = z4.object({ path: z4.string(), reason: z4.string() });
+var TEAM_SEATS_MAX = 8;
+var SeatSchema = z4.object({
+  role: RoleIdSchema,
+  tool: ToolSchema.optional(),
+  model: ModelIdSchema.optional(),
+  effort: EffortSchema.optional(),
+  name: z4.string().min(1).max(40).optional()
+});
+var uniqueRoles = (seats) => new Set(seats.map((s) => s.role)).size === seats.length;
+var SeatsSchema = z4.array(SeatSchema).min(1).max(TEAM_SEATS_MAX).refine(uniqueRoles, "a role twice in one team");
+var TeamNameSchema = z4.string().trim().min(1).max(60);
+var TeamTemplateSchema = z4.object({ id: z4.string().min(1).max(64), name: TeamNameSchema, seats: SeatsSchema, source: z4.enum(["repo", "home"]), path: z4.string() });
+var TeamIdSchema = z4.string().regex(/^team-[0-9a-f]{4,8}$/);
+var TeamStateSchema = z4.enum(["active", "resting", "dissolved"]);
+var TeamSchema = z4.object({
+  id: TeamIdSchema,
+  name: TeamNameSchema,
+  template: z4.string().optional(),
+  project: z4.string().nullable(),
+  machine: z4.string(),
+  cwd: z4.string(),
+  state: TeamStateSchema,
+  seats: z4.array(z4.object({ role: RoleIdSchema, sessionId: z4.string().nullable() })).max(TEAM_SEATS_MAX * 2),
+  createdAt: z4.string(),
+  updatedAt: z4.string(),
+  restingAt: z4.string().optional(),
+  dissolvedAt: z4.string().optional()
+});
+var RolesListSchema = z4.object({ type: z4.literal("roles.list"), cwd: z4.string().min(1).optional(), requestId: z4.string().max(100).optional(), machineId: z4.string().optional() });
+var RolesListingSchema = z4.object({
+  type: z4.literal("roles.listing"),
+  requestId: z4.string().optional(),
+  roles: z4.array(RoleSchema),
+  templates: z4.array(TeamTemplateSchema).default([]),
+  problems: z4.array(DefinitionProblemSchema),
+  /** Set by the fleet when the project's machine could not answer (#99): 'offline', or 'outdated' for a daemon without roles.list. */
+  error: z4.string().optional()
+});
+var TeamLaunchSchema = z4.object({
+  type: z4.literal("team.launch"),
+  rid: z4.string().min(1).max(100),
+  cwd: z4.string().min(1).optional(),
+  template: z4.string().min(1).max(64).optional(),
+  seats: SeatsSchema.optional(),
+  name: TeamNameSchema.optional(),
+  qid: z4.string().min(1).optional(),
+  machineId: z4.string().optional()
+});
+var TeamJoinSchema = z4.object({ type: z4.literal("team.join"), team: TeamIdSchema, session: z4.string().min(1), role: RoleIdSchema });
+var TeamLeaveSchema = z4.object({ type: z4.literal("team.leave"), team: TeamIdSchema, session: z4.string().min(1) });
+var TeamResumeSchema = z4.object({ type: z4.literal("team.resume"), team: TeamIdSchema });
+var TeamDissolveSchema = z4.object({ type: z4.literal("team.dissolve"), team: TeamIdSchema });
+var TeamSaveSchema = z4.object({ type: z4.literal("team.save"), rid: z4.string().min(1).max(100), name: TeamNameSchema, seats: SeatsSchema, qid: z4.string().min(1).optional() });
+var TeamsMessageSchema = z4.object({ type: z4.literal("teams"), teams: z4.array(TeamSchema) });
+var TeamUpdatedSchema = z4.object({ type: z4.literal("team.updated"), team: TeamSchema });
+var TeamLaunchedSchema = z4.object({ type: z4.literal("team.launched"), rid: z4.string(), team: TeamSchema });
+var TeamFailedSchema = z4.object({ type: z4.literal("team.failed"), rid: z4.string(), reason: z4.string(), team: TeamSchema.optional() });
+var TeamSavedSchema = z4.object({ type: z4.literal("team.saved"), rid: z4.string(), path: z4.string().optional(), reason: z4.string().optional() });
+var isTeamLive = (t) => t.state !== "dissolved";
+
+// ../protocol/src/tasks.ts
+import { z as z5 } 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 = z5.object({
+  at: z5.string(),
+  by: z5.string(),
+  what: z5.string(),
+  op: z5.enum(TASK_OPS).optional(),
+  from: z5.string().optional(),
+  to: z5.string().optional(),
+  fromName: z5.string().optional(),
+  toName: z5.string().optional(),
+  note: z5.string().optional()
+});
+var TaskSchema = z5.object({
+  id: z5.string(),
+  title: z5.string(),
+  text: z5.string().optional(),
+  giver: z5.string(),
+  giverName: z5.string(),
+  owner: z5.string(),
+  ownerName: z5.string(),
+  state: z5.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z5.string().optional(),
+  /** The live team its owner sat in when it was given (or passed), so a team's tasks can be listed. */
+  team: z5.string().optional(),
+  /** A task Ledge gave and the user put away from « À toi » once closed. */
+  seen: z5.boolean().optional(),
+  at: z5.string(),
+  updatedAt: z5.string(),
+  log: z5.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 = z5.object({
+  type: z5.literal("task.cmd"),
+  rid: z5.string().min(1),
+  by: z5.string().min(1),
+  op: z5.enum(["give", "take", "done", "refuse", "pass", "show", "list", "seen", "cancel"]),
+  task: z5.string().min(1).max(40).optional(),
+  to: z5.string().min(1).optional(),
+  title: z5.string().min(1).max(TASK_TITLE_MAX).optional(),
+  text: z5.string().max(TASK_TEXT_MAX).optional(),
+  all: z5.boolean().optional(),
+  team: z5.string().min(1).max(40).optional(),
+  qid: z5.string().min(1).optional(),
+  row: z5.number().int().min(0).max(7).optional()
+});
+var TaskUpdatedSchema = z5.object({ type: z5.literal("task.updated"), task: TaskSchema });
+var TaskResultSchema = z5.object({
+  type: z5.literal("task.result"),
+  rid: z5.string(),
+  task: TaskSchema.optional(),
+  tasks: z5.array(TaskSchema).optional(),
+  reason: z5.string().optional()
+});
+
+// ../protocol/src/actions.ts
+import { z as z8 } from "zod";
+
+// ../protocol/src/proposal.ts
+import { z as z6 } from "zod";
+var ProposalBlockSchema = z6.object({ cwd: z6.string().trim().min(1), prompt: z6.string().optional() });
+var RelayBlockSchema = z6.object({ session: z6.string().trim().min(1), text: z6.string().trim().min(1) });
+var ProjectBlockSchema = z6.object({
+  name: z6.string().trim().min(1).max(80),
+  description: z6.string().max(500).optional(),
+  repos: z6.array(z6.object({ path: z6.string().min(1).max(4096), why: z6.string().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z6.string().trim().max(80).optional()
+});
+var CloseBlockSchema = z6.object({ session: z6.string().trim().min(1) });
+var TeamBlockSchema = z6.object({
+  cwd: z6.string().trim().min(1),
+  template: z6.string().trim().min(1).max(64).optional(),
+  name: z6.string().trim().min(1).max(60).optional(),
+  seats: z6.array(z6.object({ role: z6.string().trim().min(1).max(40), tool: z6.enum(["claude", "codex", "cursor", "omp"]).optional(), model: z6.string().max(200).optional(), effort: z6.string().max(20).optional(), name: z6.string().max(40).optional() })).min(1).max(8).optional()
+}).refine((b) => !!b.template || !!b.seats?.length, "a template or seats");
+var TaskBlockSchema = z6.object({
+  to: z6.string().trim().min(1).max(80),
+  team: z6.string().trim().max(40).optional(),
+  title: z6.string().trim().min(1).max(200),
+  text: z6.string().max(2e4).optional()
+});
+var BLOCK = /```ledge-(session|relay|project|close|team|task|action)[ \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 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/decisions.ts
+import { z as z7 } from "zod";
+var DecisionSchema = z7.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/actions.ts
+var ActionRiskSchema = z8.enum(["read", "reversible", "destructive"]);
+var ACTION_IDS = [
+  "session.launch",
+  "session.relay",
+  "session.close",
+  "project.propose",
+  "team.launch",
+  "task.give",
+  "session.model",
+  "session.interrupt",
+  "session.archive",
+  "session.restore",
+  "session.resume",
+  "session.decide",
+  "team.join",
+  "team.leave",
+  "team.resume",
+  "team.dissolve",
+  "team.save",
+  "task.cancel",
+  "task.pass"
+];
+var ActionIdSchema = z8.enum(ACTION_IDS);
+var def = (d) => d;
+var SessionRef = z8.string().trim().min(1).max(80);
+var TeamRef = z8.string().trim().min(1).max(60);
+var TaskRef = z8.string().trim().min(1).max(40);
+var LaunchArgs = ProposalBlockSchema.extend({ model: ModelIdSchema.optional(), effort: EffortSchema.optional() });
+var ACTIONS = [
+  def({
+    id: "session.launch",
+    args: LaunchArgs,
+    card: "launch",
+    phone: "launch",
+    risk: "reversible",
+    max: 8,
+    summary: "ouvrir une session d'agent dans un dossier, avec sa premi\xE8re instruction",
+    when: "quand l'utilisateur demande explicitement d'ouvrir ou de lancer une session, et seulement si le dossier est s\xFBr : un chemin absolu lu dans sessions.md ou folders.md, ou donn\xE9 tel quel par l'utilisateur ; une action par session, et pour un dossier incertain cite les candidats et demande lequel. model et effort seulement si l'utilisateur les demande",
+    example: { cwd: "/home/alice/projets/api", prompt: "Lance les tests et corrige ceux qui \xE9chouent" }
+  }),
+  def({
+    id: "session.relay",
+    args: RelayBlockSchema,
+    card: "relay",
+    phone: null,
+    risk: "reversible",
+    max: 1,
+    summary: "envoyer une instruction \xE0 une session (tout de suite si elle est libre, sinon d\xE8s qu'elle le sera)",
+    when: "quand l'utilisateur demande explicitement de dire, demander ou envoyer quelque chose \xE0 une session, et seulement si une seule session correspond et qu'elle n'est pas en lecture seule ; le texte est formul\xE9 pour l'agent",
+    example: { session: "Nova", text: "Ajoute un test pour le cas o\xF9 la liste est vide" }
+  }),
+  def({
+    id: "session.close",
+    args: CloseBlockSchema,
+    card: "close",
+    phone: "close",
+    risk: "reversible",
+    max: 8,
+    cli: "ledge close <session>",
+    summary: "fermer proprement une session ; sa conversation reste reprenable",
+    when: "quand l'utilisateur demande explicitement de fermer, clore, arr\xEAter ou quitter des sessions qui correspondent sans ambigu\xEFt\xE9, pas en lecture seule ni d\xE9j\xE0 termin\xE9es. S'il veut d'abord un point de reprise, propose seulement le relais de cette demande",
+    example: { session: "Nova" }
+  }),
+  def({
+    id: "project.propose",
+    args: ProjectBlockSchema,
+    card: "project",
+    phone: null,
+    risk: "reversible",
+    max: 1,
+    summary: "cr\xE9er un projet, ou compl\xE9ter un projet existant (addTo), avec ses d\xE9p\xF4ts",
+    when: "seulement si l'utilisateur demande explicitement de cr\xE9er ou de compl\xE9ter un projet : lis projects.md, ne cite que des chemins absolus lus dans sessions.md, folders.md ou projects.md, jamais un d\xE9p\xF4t qui appartient d\xE9j\xE0 \xE0 un projet ; ta r\xE9ponse dit le nom, chaque d\xE9p\xF4t et pourquoi",
+    example: { name: "Facturation", description: "Le service et son front", repos: [{ path: "/home/alice/projets/billing-api", why: "le service" }] }
+  }),
+  def({
+    id: "team.launch",
+    args: TeamBlockSchema,
+    card: "team",
+    phone: "launch",
+    risk: "reversible",
+    max: 1,
+    cli: "ledge team up <mod\xE8le> --cwd <dossier>",
+    summary: "monter une \xE9quipe dans un dossier : un mod\xE8le de teams.md (template), ou des si\xE8ges (r\xF4le de roles.md, agent, et si demand\xE9 model, effort)",
+    when: "quand l'utilisateur demande explicitement de monter, lancer ou composer une \xE9quipe, avec la m\xEAme r\xE8gle de dossier s\xFBr qu'une session ; 8 si\xE8ges au plus, un r\xF4le une seule fois, seulement des r\xF4les de roles.md disponibles dans ce dossier (s'il en manque un, dis lequel et le fichier \xE0 \xE9crire, ~/.ledge/roles/<id>.md). Ne choisis jamais l'autonomie : c'est celle du r\xF4le",
+    example: { cwd: "/home/alice/projets/api", name: "api", seats: [{ role: "dev-back", tool: "claude" }, { role: "rev-back", tool: "codex" }] }
+  }),
+  def({
+    id: "task.give",
+    args: TaskBlockSchema,
+    card: "task",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    cli: 'ledge task give <session|@r\xF4le> "<titre>" "<d\xE9tail>"',
+    summary: "confier une t\xE2che \xE0 une session, ou \xE0 un @r\xF4le d'une \xE9quipe (team : son id dans teams.md ; sans team, un si\xE8ge de l'\xE9quipe propos\xE9e dans la m\xEAme r\xE9ponse)",
+    when: "quand l'utilisateur demande explicitement de confier une t\xE2che, ou juste apr\xE8s team.launch quand il a dit ce que l'\xE9quipe doit faire. Une fois l'\xE9quipe lanc\xE9e, ne propose rien pour ce que les si\xE8ges se confient entre eux",
+    example: { to: "@dev-back", title: "Pagination de /invoices", text: "Ajoute la pagination par curseur et ses tests" }
+  }),
+  def({
+    id: "session.model",
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    args: z8.object({ session: SessionRef, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+    summary: "changer le mod\xE8le et l'effort d'une session en cours (null : le d\xE9faut de l'agent) ; elle red\xE9marre sur la m\xEAme conversation, \xE0 son prochain moment libre",
+    when: "quand l'utilisateur demande de passer une session sur un autre mod\xE8le ou un autre effort",
+    example: { session: "Nova", model: "claude-opus-5-5", effort: "high" }
+  }),
+  def({
+    id: "session.interrupt",
+    args: z8.object({ session: SessionRef }),
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    summary: "interrompre le tour en cours d'une session (comme \xC9chap) ; la session reste ouverte",
+    when: "quand l'utilisateur demande d'interrompre, de stopper ou d'arr\xEAter ce que fait une session sans la fermer",
+    example: { session: "Nova" }
+  }),
+  def({
+    id: "session.archive",
+    args: z8.object({ session: SessionRef }),
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    summary: "archiver une session termin\xE9e : elle quitte la liste mais est gard\xE9e (restaurable)",
+    when: "quand l'utilisateur demande d'archiver ou de ranger des sessions ; une session encore en cours se ferme d'abord : propose session.close puis session.archive, dans cet ordre, dans la m\xEAme r\xE9ponse",
+    example: { session: "Nova" }
+  }),
+  def({
+    id: "session.restore",
+    args: z8.object({ session: SessionRef }),
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    summary: "sortir une session de l'archive, telle qu'elle \xE9tait",
+    when: "quand l'utilisateur demande de restaurer une session archiv\xE9e",
+    example: { session: "Nova" }
+  }),
+  def({
+    id: "session.resume",
+    args: z8.object({ session: SessionRef }),
+    card: "generic",
+    phone: "act",
+    risk: "reversible",
+    max: 8,
+    summary: "relancer l'agent d'une session termin\xE9e sur sa conversation",
+    when: "quand l'utilisateur demande de reprendre ou relancer une session termin\xE9e",
+    example: { session: "Nova" }
+  }),
+  def({
+    id: "session.decide",
+    card: "generic",
+    phone: "act",
+    max: 1,
+    args: z8.object({ session: SessionRef, decision: z8.enum(["accept", "deny"]), note: z8.string().trim().min(1).max(NOTE_MAX).optional() }),
+    risk: (a) => a.decision === "accept" ? "destructive" : "reversible",
+    summary: "accepter ou refuser la demande en attente d'une session (permission, diff ou plan), note possible avec un refus ; jamais \xAB toujours \xBB",
+    when: "seulement quand l'utilisateur demande explicitement d'accepter ou de refuser la demande d'une session pr\xE9cise, et que sessions.md montre une demande en attente pour elle ; cite la demande telle quelle dans ta r\xE9ponse",
+    example: { session: "Nova", decision: "deny", note: "Pas sur main : cr\xE9e une branche" }
+  }),
+  def({
+    id: "team.join",
+    args: z8.object({ team: TeamRef, session: SessionRef, role: RoleIdSchema }),
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    summary: "faire entrer une session dans une \xE9quipe en cours, \xE0 un r\xF4le de roles.md",
+    when: "quand l'utilisateur demande d'ajouter une session existante \xE0 une \xE9quipe",
+    example: { team: "team-3fa2", session: "Nova", role: "dev-back" }
+  }),
+  def({
+    id: "team.leave",
+    args: z8.object({ team: TeamRef, session: SessionRef }),
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    summary: "faire sortir une session d'une \xE9quipe (la session continue)",
+    when: "quand l'utilisateur demande de retirer une session d'une \xE9quipe",
+    example: { team: "team-3fa2", session: "Nova" }
+  }),
+  def({
+    id: "team.resume",
+    args: z8.object({ team: TeamRef }),
+    card: "generic",
+    phone: "act",
+    risk: "reversible",
+    max: 1,
+    summary: "reprendre une \xE9quipe au repos : chaque si\xE8ge reprend sa conversation",
+    when: "quand l'utilisateur demande de reprendre ou relancer une \xE9quipe au repos",
+    example: { team: "team-3fa2" }
+  }),
+  def({
+    id: "team.dissolve",
+    args: z8.object({ team: TeamRef }),
+    card: "generic",
+    phone: "act",
+    risk: "destructive",
+    max: 1,
+    cli: "ledge team dissolve <\xE9quipe>",
+    summary: "dissoudre une \xE9quipe : elle dispara\xEEt, ses sessions restent ; irr\xE9versible",
+    when: "seulement quand l'utilisateur demande explicitement de dissoudre une \xE9quipe pr\xE9cise",
+    example: { team: "team-3fa2" }
+  }),
+  def({
+    id: "team.save",
+    args: z8.object({ team: TeamRef, name: TeamNameSchema }),
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 1,
+    summary: "enregistrer une \xE9quipe en cours comme mod\xE8le (~/.ledge/teams/<nom>.yaml)",
+    when: "quand l'utilisateur demande d'enregistrer ou de garder la composition d'une \xE9quipe",
+    example: { team: "team-3fa2", name: "api" }
+  }),
+  def({
+    id: "task.cancel",
+    args: z8.object({ task: TaskRef, reason: z8.string().trim().min(1).max(500).optional() }),
+    card: "generic",
+    phone: "act",
+    risk: "destructive",
+    max: 8,
+    summary: "annuler une t\xE2che ouverte ou prise ; la session qui la tient est pr\xE9venue ; irr\xE9versible",
+    when: "seulement quand l'utilisateur demande explicitement d'annuler une t\xE2che de tasks.md",
+    example: { task: "t91b0d4", reason: "Plus n\xE9cessaire" }
+  }),
+  def({
+    id: "task.pass",
+    args: z8.object({ task: TaskRef, to: SessionRef, note: z8.string().trim().min(1).max(TASK_TEXT_MAX).optional() }),
+    card: "generic",
+    phone: null,
+    risk: "reversible",
+    max: 8,
+    summary: "passer une t\xE2che de tasks.md \xE0 une autre session (elle redevient ouverte)",
+    when: "quand l'utilisateur demande de r\xE9assigner ou de passer une t\xE2che \xE0 une autre session",
+    example: { task: "t91b0d4", to: "Bix" }
+  })
+];
+var byId = new Map(ACTIONS.map((a) => [a.id, a]));
+var actionById = (id) => byId.get(id);
+var riskOf = (a, args) => typeof a.risk === "function" ? a.risk(args) : a.risk;
+var ActionBlockSchema = z8.object({ action: z8.string().trim().min(1).max(40), args: z8.record(z8.unknown()).default({}) });
+var LEGACY_FENCE_ACTION = {
+  session: "session.launch",
+  relay: "session.relay",
+  close: "session.close",
+  project: "project.propose",
+  team: "team.launch",
+  task: "task.give"
+};
+function parseActionBlock(kind, raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return { error: "invalid JSON" };
+  }
+  let id;
+  let args;
+  if (kind === "action") {
+    const b = ActionBlockSchema.safeParse(json);
+    if (!b.success) return { error: "not an {action, args} object" };
+    id = b.data.action;
+    args = b.data.args;
+  } else {
+    id = LEGACY_FENCE_ACTION[kind];
+    args = json;
+  }
+  const action = actionById(id);
+  if (!action) return { error: `unknown action ${id}` };
+  const parsed = action.args.safeParse(args);
+  if (!parsed.success) return { error: `invalid args for ${id}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"} ${i.message}`).join("; ")}` };
+  return { action, args: parsed.data };
+}
+var NEVER_PROPOSED = [
+  "tuer (kill) ou supprimer une session, la retirer de la liste",
+  "mettre \xE0 jour le daemon",
+  "changer les machines, les r\xE9glages, l'acc\xE8s mobile",
+  "modifier les projets autrement que par la carte de projet",
+  "cr\xE9er un dossier",
+  "r\xE9pondre \xAB toujours \xBB \xE0 une demande, ou r\xE9pondre aux questions \xE0 choix d'OMP"
+];
+
+// ../protocol/src/messages.ts
+import { z as z21 } from "zod";
+
+// ../protocol/src/chat.ts
+import { z as z10 } from "zod";
+
+// ../protocol/src/attachments.ts
+import { z as z9 } from "zod";
+var ATTACHMENT_ID = /^[0-9a-f]{64}$/;
+var AttachmentIdSchema = z9.string().regex(ATTACHMENT_ID);
+var IMAGE_MIMES = ["image/webp", "image/jpeg", "image/png", "image/gif"];
+var ImageMimeSchema = z9.enum(IMAGE_MIMES);
+var ATTACHMENT_MAX = 4e5;
+var ATTACHMENT_LOCAL_MAX = 2e6;
+var PREVIEW_MAX = 4e4;
+var ATTACHMENTS_MAX = 5;
+var b64Max = (bytes) => Math.ceil(bytes / 3) * 4;
+var AttachmentRefSchema = z9.object({
+  id: AttachmentIdSchema,
+  mime: ImageMimeSchema,
+  width: z9.number().int().positive(),
+  height: z9.number().int().positive(),
+  bytes: z9.number().int().positive(),
+  preview: z9.boolean()
+});
+var ImageUploadSchema = z9.object({
+  mime: ImageMimeSchema,
+  data: z9.string().min(1).max(b64Max(ATTACHMENT_LOCAL_MAX)),
+  preview: z9.object({ mime: ImageMimeSchema, data: z9.string().min(1).max(b64Max(PREVIEW_MAX)) }).optional()
+});
+var AttachmentErrorReasonSchema = z9.enum(["too_large", "not_image", "unreadable", "not_found", "offline"]);
+var requestId = z9.string().min(1).max(100);
+var AttachmentPutSchema = z9.object({ type: z9.literal("attachment.put"), requestId, id: z9.string().optional(), image: ImageUploadSchema });
+var AttachmentGetSchema = z9.object({ type: z9.literal("attachment.get"), requestId, attachment: AttachmentIdSchema, preview: z9.boolean().optional(), id: z9.string().optional(), machine: z9.string().optional() });
+var AttachmentStoredSchema = z9.object({ type: z9.literal("attachment.stored"), requestId, ref: AttachmentRefSchema });
+var AttachmentDataSchema = z9.object({ type: z9.literal("attachment.data"), requestId, attachment: AttachmentIdSchema, mime: ImageMimeSchema, data: z9.string() });
+var AttachmentErrorSchema = z9.object({ type: z9.literal("attachment.error"), requestId, reason: AttachmentErrorReasonSchema });
+
+// ../protocol/src/chat.ts
+var ChatStepSchema = z10.object({
+  kind: z10.enum(["sessions", "pane", "reply", "git", "repo"]),
+  id: z10.string().optional(),
+  name: z10.string().optional(),
+  path: z10.string().optional()
+});
+var ChatProposalSchema = z10.object({
+  cwd: z10.string().min(1),
+  project: z10.string(),
+  prompt: z10.string().optional(),
+  tool: ToolSchema,
+  /** What Ledge proposed on the card's picker (spec 2026-10-26 action registry §4), the agent's own default when left out. */
+  model: ModelIdSchema.optional(),
+  effort: EffortSchema.optional(),
+  launchedId: z10.string().optional(),
+  error: z10.string().optional()
+});
+var MAX_PROPOSALS = 8;
+var ChatProposalsSchema = z10.array(ChatProposalSchema).min(1).max(MAX_PROPOSALS);
+var ChatRelaySchema = z10.object({
+  id: z10.string().min(1),
+  name: z10.string(),
+  tool: ToolSchema,
+  text: z10.string().min(1),
+  status: z10.enum(["queued", "sent"]).optional(),
+  sentAt: z10.string().datetime().optional(),
+  error: z10.string().optional()
+});
+var ChatCloseSchema = z10.object({
+  id: z10.string().min(1),
+  name: z10.string(),
+  tool: ToolSchema,
+  closedAt: z10.string().datetime().optional(),
+  how: z10.enum(["exit", "killed"]).optional(),
+  error: z10.string().optional()
+});
+var ChatClosesSchema = z10.array(ChatCloseSchema).min(1).max(MAX_PROPOSALS);
+var ChatProjectProposalSchema = z10.object({
+  name: z10.string().min(1).max(80),
+  description: z10.string().max(500).optional(),
+  repos: z10.array(z10.object({ path: z10.string().min(1).max(4096), why: z10.string().min(1).max(200) })).min(1).max(50),
+  addTo: z10.string().min(1).max(80).optional()
+});
+var ChatTeamSeatSchema = z10.object({
+  role: z10.string().min(1),
+  label: z10.string(),
+  tool: ToolSchema,
+  model: z10.string().optional(),
+  effort: z10.string().optional(),
+  autonomy: AutonomySchema.optional(),
+  name: z10.string().optional()
+});
+var ChatTeamProposalSchema = z10.object({
+  cwd: z10.string().min(1),
+  project: z10.string(),
+  projectName: z10.string().optional(),
+  name: z10.string().min(1),
+  template: z10.string().optional(),
+  seats: z10.array(ChatTeamSeatSchema).min(1).max(8),
+  teamId: z10.string().optional(),
+  launchedAt: z10.string().datetime().optional(),
+  error: z10.string().optional(),
+  savedPath: z10.string().optional()
+});
+var ChatTaskProposalSchema = z10.object({
+  to: z10.string().min(1),
+  toName: z10.string().optional(),
+  team: z10.string().optional(),
+  title: z10.string().min(1).max(200),
+  text: z10.string().max(2e4).optional(),
+  taskId: z10.string().optional(),
+  ownerName: z10.string().optional(),
+  state: z10.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  givenAt: z10.string().datetime().optional(),
+  error: z10.string().optional()
+});
+var ChatTasksSchema = z10.array(ChatTaskProposalSchema).min(1).max(MAX_PROPOSALS);
+var ActionVarsSchema = z10.record(z10.string().max(40), z10.string().max(300));
+var DETAIL_MAX = 4e3;
+var ACTION_ERROR_CODES = [
+  "unknown",
+  "ambiguous",
+  "read_only",
+  "exited",
+  "running",
+  "archived",
+  "not_archived",
+  "no_terminal",
+  "same_model",
+  "no_request",
+  "in_session",
+  "no_note",
+  "member",
+  "not_member",
+  "unknown_role",
+  "not_resting",
+  "dissolved",
+  "no_seat",
+  "closed",
+  "holder",
+  "changed",
+  "cut",
+  "failed"
+];
+var ChatActionStateSchema = z10.enum(["running", "done", "denied", "failed", "refused"]);
+var ChatActionSchema = z10.object({
+  action: z10.string().min(1).max(40),
+  args: z10.record(z10.unknown()),
+  summary: z10.string().min(1).max(300),
+  vars: ActionVarsSchema.optional(),
+  detail: z10.string().max(DETAIL_MAX).optional(),
+  detailCut: z10.literal(true).optional(),
+  risk: ActionRiskSchema,
+  session: z10.string().optional(),
+  team: z10.string().optional(),
+  state: ChatActionStateSchema.optional(),
+  doneAt: z10.string().datetime().optional(),
+  error: z10.string().optional(),
+  code: z10.string().max(40).optional()
+});
+var ChatActionsSchema = z10.array(ChatActionSchema).min(1).max(MAX_PROPOSALS);
+var ChatTurnSchema = z10.object({
+  machineId: z10.string().optional(),
+  machineName: z10.string().optional(),
+  choices: z10.array(z10.object({ id: z10.string(), label: z10.string() })).optional(),
+  qid: z10.string().min(1),
+  question: z10.string(),
+  askedAt: z10.string().datetime(),
+  steps: z10.array(ChatStepSchema),
+  answer: z10.string().optional(),
+  answeredAt: z10.string().datetime().optional(),
+  error: z10.string().optional(),
+  proposal: ChatProposalSchema.optional(),
+  proposals: ChatProposalsSchema.optional(),
+  relay: ChatRelaySchema.optional(),
+  closes: ChatClosesSchema.optional(),
+  projectProposal: ChatProjectProposalSchema.optional(),
+  team: ChatTeamProposalSchema.optional(),
+  tasks: ChatTasksSchema.optional(),
+  actions: ChatActionsSchema.optional(),
+  ignoredAt: z10.string().datetime().optional(),
+  attachments: z10.array(AttachmentRefSchema).optional()
+});
+var proposalRows = (t) => t?.proposals ?? (t?.proposal ? [t.proposal] : []);
+
+// ../protocol/src/repos.ts
+import { z as z11 } from "zod";
+var ReposInspectSchema = z11.object({
+  type: z11.literal("repos.inspect"),
+  requestId: z11.string().min(1).max(100),
+  paths: z11.array(z11.string().min(1)).min(1).max(50),
+  machineId: z11.string().optional()
+});
+var RepoInfoSchema = z11.object({ path: z11.string(), exists: z11.boolean(), branch: z11.string().nullable() });
+var ReposInfoSchema = z11.object({ type: z11.literal("repos.info"), requestId: z11.string(), repos: z11.array(RepoInfoSchema) });
+
+// ../protocol/src/scan.ts
+import { z as z12 } from "zod";
+var ReposScanSchema = z12.object({ type: z12.literal("repos.scan"), requestId: z12.string().min(1).max(100), machineId: z12.string().optional() });
+var FoundRepoSchema = z12.object({ path: z12.string(), branch: z12.string().nullable(), remote: z12.string().optional(), manifest: z12.string().max(200).optional() });
+var ReposFoundSchema = z12.object({ type: z12.literal("repos.found"), requestId: z12.string(), repos: z12.array(FoundRepoSchema).max(500), truncated: z12.boolean(), error: z12.string().optional() });
+
+// ../protocol/src/documents.ts
+import { z as z13 } from "zod";
+var DOCUMENT_MAX_BYTES = 1048576;
+var path = z13.string().min(1).max(4096);
+var requestId2 = z13.string().min(1);
+var DocumentReadSchema = z13.object({
+  type: z13.literal("document.read"),
+  requestId: requestId2,
+  path,
+  machineId: z13.string().optional(),
+  sessionId: z13.string().min(1).optional(),
+  basePath: path.optional()
+});
+var DocumentContentSchema = z13.object({
+  type: z13.literal("document.content"),
+  requestId: requestId2,
+  path,
+  text: z13.string(),
+  bytes: z13.number().int().nonnegative(),
+  modifiedAt: z13.string().datetime()
+});
+var DocumentErrorCodeSchema = z13.enum([
+  "not_found",
+  "not_file",
+  "unsupported_path",
+  "unsupported_type",
+  "permission_denied",
+  "too_large",
+  "invalid_utf8",
+  "ambiguous_path",
+  "session_missing",
+  "read_failed"
+]);
+var DocumentErrorSchema = z13.object({
+  type: z13.literal("document.error"),
+  requestId: requestId2,
+  path,
+  code: DocumentErrorCodeSchema
+});
+
+// ../protocol/src/routing.ts
+import { z as z14 } from "zod";
+var MachineInventorySchema = z14.object({
+  id: z14.string().min(1).max(80),
+  label: z14.string().min(1).max(120),
+  online: z14.boolean(),
+  local: z14.boolean(),
+  sessions: z14.array(z14.object({ id: z14.string(), name: z14.string(), project: z14.string(), cwd: z14.string(), topic: z14.string().optional(), state: z14.string(), readOnly: z14.boolean() })).max(500),
+  folders: z14.array(z14.object({ project: z14.string(), cwd: z14.string() })).max(100)
+});
+var RoutingContextSchema = z14.object({
+  machines: z14.array(MachineInventorySchema).min(1).max(20),
+  history: z14.array(z14.object({ question: z14.string().max(2e4), answer: z14.string().max(2e4).optional(), machineId: z14.string().optional() })).max(50)
+});
+var RouteResultSchema = z14.object({
+  /** Null means an answer or a clarification, never an implicit local destination. */
+  machineId: z14.string().nullable(),
+  text: z14.string().min(1).max(2e4),
+  choices: z14.array(z14.string()).max(20).optional()
+});
+
+// ../protocol/src/ssh.ts
+import { z as z15 } from "zod";
+var SshAliasSchema = z15.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
+
+// ../protocol/src/machines.ts
+import { z as z16 } from "zod";
+var MachineIdSchema = z16.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+var MachineSchema = z16.object({
+  id: MachineIdSchema,
+  label: z16.string().trim().min(1).max(80),
+  ssh: SshAliasSchema.optional()
+});
+var MachinesSchema = z16.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 z17 } from "zod";
+var IslandScaleSchema = z17.union([z17.literal("auto"), z17.literal(1), z17.literal(1.25), z17.literal(1.5), z17.literal(2)]);
+var IslandPrefsSchema = z17.object({
+  /** Shown at the top of the screen; hidden, Desktop still notifies. */
+  visible: z17.boolean(),
+  /** `primary` (whichever it is after a reconfiguration), or a monitor's id as the shell lists it (`list_monitors`: the OS
+   *  name, `#index` without one). `second`, written by older fronts, is the first monitor that is not the primary. */
+  screen: z17.string().trim().min(1).max(200),
+  position: z17.enum(["center", "left", "right"]),
+  /** A strip under a maximised window. */
+  discreet: z17.boolean(),
+  islandScale: IslandScaleSchema,
+  panelScale: IslandScaleSchema,
+  /** What the island shows besides asks and questions, which it always shows. */
+  shows: z17.object({
+    /** Allow, deny or answer in a line from the island; off, its cards only say « Open in Ledge ». */
+    quick: z17.boolean(),
+    /** The 6 s bubble when an agent finishes. */
+    finished: z17.boolean(),
+    /** An agent's sentence in a bubble. */
+    say: z17.boolean(),
+    /** The sub-agents next to their main agent. */
+    helpers: z17.boolean()
+  }),
+  /** The global shortcut that opens the island, as shown (`Ctrl Alt L`). */
+  shortcut: z17.string().trim().min(1).max(40)
+});
+
+// ../protocol/src/projects.ts
+import { z as z18 } from "zod";
+var PROJECT_COLORS = { blue: "#3b82f6", green: "#10b981", amber: "#f59e0b", violet: "#8b5cf6", teal: "#14b8a6", pink: "#ec4899", red: "#ef4444", slate: "#64748b" };
+var ProjectColorSchema = z18.enum(["blue", "green", "amber", "violet", "teal", "pink", "red", "slate"]);
+var ProjectIdSchema = z18.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+function normalizePath(raw) {
+  const p = raw.trim().replace(/\/+/g, "/");
+  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+}
+var PathSchema = z18.string().max(4096).refine((p) => p.startsWith("/") && p === normalizePath(p), "an absolute, normalized path");
+var RepoSchema = z18.object({ machine: MachineIdSchema, path: PathSchema });
+var ProjectSchema = z18.object({
+  id: ProjectIdSchema,
+  name: z18.string().trim().min(1).max(80),
+  color: ProjectColorSchema,
+  description: z18.string().max(500).default(""),
+  repos: z18.array(RepoSchema).max(50)
+});
+var RuleSchema = z18.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 = z18.object({ projects: z18.array(ProjectSchema).max(100), rules: z18.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 z19 } from "zod";
+var ToolStatusSchema = z19.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z19.object({ path: z19.string().min(1), from: z19.string().min(1).optional(), change: z19.enum(["add", "edit", "delete", "write"]), diff: z19.string().optional() });
+var base = { id: z19.string().min(1), at: z19.string().datetime(), turn: z19.number().int().nonnegative(), helperId: z19.string().optional() };
+var ThreadItemSchema = z19.discriminatedUnion("kind", [
+  z19.object({ kind: z19.literal("prompt"), ...base, text: z19.string(), images: z19.array(AttachmentRefSchema).optional() }),
+  z19.object({ kind: z19.literal("message"), ...base, text: z19.string() }),
+  /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row; `byClose`: a question
+   *  dismissed by Ledge closing the session. */
+  z19.object({ kind: z19.literal("tool"), ...base, tool: z19.string(), label: z19.string(), input: z19.string().optional(), output: z19.string().optional(), error: z19.string().optional(), status: ToolStatusSchema, durationMs: z19.number().nonnegative().optional(), files: z19.array(FileChangeSchema).default([]), byClose: z19.literal(true).optional() }),
+  /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again;
+   *  `byClose`: denied by Ledge closing the session. */
+  z19.object({ kind: z19.literal("permission"), ...base, tool: z19.string(), text: z19.string(), decision: z19.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z19.literal(true).optional() }),
+  z19.object({ kind: z19.literal("reply"), ...base, text: z19.string() }),
+  z19.object({ kind: z19.literal("helper"), ...base, task: z19.string(), agentType: z19.string().optional(), state: z19.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. */
+  z19.object({ kind: z19.literal("sent"), ...base, to: z19.string(), peer: z19.string().optional(), summary: z19.string().optional(), text: z19.string(), status: z19.enum(["sending", "delivered", "read", "failed"]), received: z19.string().optional(), via: z19.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. */
+  z19.object({ kind: z19.literal("received"), ...base, from: z19.string(), peer: z19.string().optional(), text: z19.string(), sent: z19.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`. */
+  z19.object({
+    kind: z19.literal("notice"),
+    ...base,
+    notice: z19.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: z19.string().optional(),
+    team: z19.string().optional(),
+    /** A task this session handed over (`outgoing`), and how (issue #92). */
+    taskOp: z19.enum(TRANSMISSION_OPS).optional(),
+    outgoing: z19.literal(true).optional(),
+    name: z19.string().optional(),
+    peer: z19.string().optional(),
+    time: z19.string().optional(),
+    summary: z19.string().optional(),
+    status: z19.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
+    count: z19.number().int().positive().optional(),
+    recipients: z19.array(z19.string()).optional(),
+    reason: z19.string().optional(),
+    text: z19.string()
+  })
+]);
+
+// ../protocol/src/mobile.ts
+import { z as z20 } from "zod";
+var DEFAULT_RELAY_URL = "https://app.kl-ledge.dev";
+var RelayUrlSchema = z20.string().transform((v, ctx) => {
+  const bad = () => {
+    ctx.addIssue({ code: z20.ZodIssueCode.custom, message: "invalid relay URL" });
+    return z20.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 = z20.object({ enabled: z20.boolean(), relayUrl: RelayUrlSchema });
+var MobileLinkStateSchema = z20.discriminatedUnion("state", [
+  z20.object({ state: z20.literal("off") }),
+  z20.object({ state: z20.literal("connecting") }),
+  z20.object({ state: z20.literal("online") }),
+  z20.object({ state: z20.literal("offline"), retryAt: z20.string().datetime(), error: z20.string() }),
+  z20.object({ state: z20.literal("signed_out"), reason: z20.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. */
+  z20.object({ state: z20.literal("unavailable"), error: z20.string().max(200) })
+]);
+var MobilePairingSchema = z20.object({
+  id: z20.string(),
+  label: z20.string(),
+  code: z20.string().nullable(),
+  expiresAt: z20.string().datetime(),
+  state: z20.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
+});
+var MobileStateSchema = z20.object({
+  enabled: z20.boolean(),
+  relayUrl: z20.string(),
+  account: z20.object({ login: z20.string(), accountId: z20.string() }).nullable(),
+  signin: z20.object({ userCode: z20.string(), verificationUri: z20.string(), expiresAt: z20.string().datetime() }).nullable(),
+  /** The last sign-in that did not end with a session; cleared by the next one. */
+  signinError: z20.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
+  link: MobileLinkStateSchema,
+  devices: z20.array(z20.object({ id: z20.string(), label: z20.string(), approvedAt: z20.string(), online: z20.boolean(), lastSeenAt: z20.string().optional() })),
+  pairings: z20.array(MobilePairingSchema)
+});
+
+// ../protocol/src/messages.ts
+var PROTOCOL_PORT = 47831;
+var RefusalCodeSchema = z21.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid", "attachment_missing", "attachments_not_accepted"]);
+var SessionEventSchema = z21.object({
+  name: z21.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
+  at: z21.string().datetime(),
+  source: z21.enum(["hook", "pane", "daemon"]),
+  tool: z21.string().optional(),
+  text: z21.string().optional(),
+  options: z21.array(z21.string()).optional(),
+  /** Each option's description, by index ('' when it has none); left out when no option has one. */
+  optionDetails: z21.array(z21.string()).optional(),
+  kind: z21.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: z21.string().optional(),
+  exitCode: z21.number().int().nullable().optional(),
+  helperId: z21.string().optional(),
+  /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
+  task: z21.string().optional(),
+  /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
+  interrupt: z21.boolean().optional(),
+  /** UserPromptSubmit: the images the prompt carried, by attachment id. */
+  attachments: z21.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+  /** QueueUpdate: OMP's queue as it stands. */
+  queue: z21.array(z21.object({ text: z21.string(), mode: z21.enum(["steer", "follow_up"]) })).optional(),
+  /** AgentMessage: the harness's own message, its text so far (`streaming`) or whole. `messageId` is unique for the session's life. */
+  messageId: z21.string().optional(),
+  streaming: z21.boolean().optional(),
+  /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
+  requestId: z21.string().optional(),
+  questions: z21.array(AskQuestionSchema).optional(),
+  /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
+  streamed: z21.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: z21.string().optional(),
+  /** The tool's input as the harness gave it, every string capped by the hook. */
+  toolInput: z21.record(z21.string(), z21.unknown()).optional(),
+  /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
+  output: z21.string().optional(),
+  durationMs: z21.number().nonnegative().optional(),
+  /** PostToolUseFailure: the harness's error message. */
+  error: z21.string().optional(),
+  /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
+  transcriptPath: z21.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: z21.literal(true).optional(),
+  /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
+  agentSessionId: z21.string().optional()
+});
+var RecentSchema = z21.object({ cwd: z21.string().min(1), project: z21.string().min(1), lastAt: z21.string().datetime() });
+var SEMVER = /^\d+\.\d+\.\d+$/;
+var DaemonInfoSchema = z21.object({
+  version: z21.string(),
+  install: z21.enum(["npm", "git", "unknown"]),
+  systemd: z21.boolean(),
+  manual: z21.string().optional(),
+  routing: z21.boolean().optional(),
+  archive: z21.boolean().optional(),
+  /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
+  models: z21.boolean().optional(),
+  /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
+  omp: z21.boolean().optional(),
+  /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
+  modelSwitch: z21.boolean().optional(),
+  /** Takes `approval` on an OMP `session.launch` (auto mode). */
+  ompApproval: z21.boolean().optional(),
+  /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
+  home: z21.string().optional(),
+  mobile: z21.boolean().optional(),
+  /** Knows roles, teams and tasks given by Ledge (spec 2026-10-25 roles). */
+  teams: z21.boolean().optional()
+});
+var UpdateFailureSchema = z21.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z21.discriminatedUnion("type", [
+  z21.object({ type: z21.literal("chat.routed"), qid: z21.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. */
+  z21.object({ type: z21.literal("snapshot"), sessions: z21.array(SessionSchema), recents: z21.array(RecentSchema).optional(), launcher: z21.array(z21.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z21.object({ type: z21.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. */
+  z21.object({
+    type: z21.literal("session.queue.restored"),
+    id: z21.string(),
+    texts: z21.array(z21.string()),
+    /** The same instructions with the images they carried; `imagesDropped`: some images could not be put back. */
+    entries: z21.array(z21.object({ text: z21.string(), attachments: z21.array(AttachmentIdSchema).optional() })).optional(),
+    imagesDropped: z21.boolean().optional()
+  }),
+  z21.object({ type: z21.literal("session.removed"), id: z21.string() }),
+  z21.object({ type: z21.literal("session.preview"), id: z21.string(), lines: z21.array(z21.string()) }),
+  /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
+  z21.object({ type: z21.literal("session.thread"), id: z21.string(), items: z21.array(ThreadItemSchema) }),
+  z21.object({ type: z21.literal("session.thread.item"), id: z21.string(), item: ThreadItemSchema }),
+  /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
+  z21.object({ type: z21.literal("session.launched"), id: z21.string() }),
+  /** Answer to the requester of a `session.close`, once per row closed: the session `id` and how it ended. */
+  z21.object({ type: z21.literal("session.closed"), qid: z21.string(), row: z21.number().int().min(0), id: z21.string(), how: z21.enum(["exit", "killed"]) }),
+  z21.object({ type: z21.literal("recents"), recents: z21.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. */
+  z21.object({
+    type: z21.literal("folder.listing"),
+    path: z21.string(),
+    parent: z21.string().nullable(),
+    entries: z21.array(z21.string()),
+    error: z21.string().optional(),
+    /** The request this answers, when it carried one. */
+    requestId: z21.string().optional(),
+    /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
+    repos: z21.array(z21.object({ name: z21.string(), branch: z21.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. */
+  z21.object({ type: z21.literal("chat.step"), qid: z21.string(), step: ChatStepSchema }),
+  z21.object({ type: z21.literal("chat.delta"), qid: z21.string(), text: z21.string() }),
+  z21.object({ type: z21.literal("chat.done"), qid: z21.string(), text: z21.string(), at: z21.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), team: ChatTeamProposalSchema.optional(), tasks: ChatTasksSchema.optional(), actions: ChatActionsSchema.optional() }),
+  /** What a `chat.act` applied: the rows done, and the one that failed with why (the rows after it stay proposed). */
+  z21.object({ type: z21.literal("chat.acted"), rid: z21.string(), qid: z21.string(), done: z21.array(z21.number().int().min(0)), failed: z21.array(z21.object({
+    row: z21.number().int().min(0),
+    message: z21.string(),
+    /** nothing was sent */
+    refused: z21.literal(true).optional()
+  })) }),
+  /** What an `action.run` came to: `row` the action as the daemon resolved it (its summary, its risk); `reason` why it was not
+   *  done, with `code` (`refused`: not possible now; `agent`: a session may not run it; `confirm_required`: destructive, ask
+   *  again; `failed`: the handler turned it down; a free string, as an `error`'s); `path` the template a `team.save` wrote. */
+  z21.object({ type: z21.literal("action.result"), rid: z21.string(), action: z21.string().min(1).max(40), row: ChatActionSchema.optional(), reason: z21.string().optional(), code: z21.string().optional(), path: z21.string().optional() }),
+  z21.object({ type: z21.literal("chat.error"), qid: z21.string(), message: z21.string() }),
+  z21.object({ type: z21.literal("chat.history"), turns: z21.array(ChatTurnSchema) }),
+  /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
+  z21.object({ type: z21.literal("update.progress"), version: z21.string(), step: z21.enum(["installing", "restarting"]) }),
+  /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
+  z21.object({ type: z21.literal("update.failed"), version: z21.string(), reason: UpdateFailureSchema, detail: z21.string().optional(), command: z21.string().optional() }),
+  /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
+  z21.object({ type: z21.literal("machines"), machines: MachinesSchema }),
+  /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
+  z21.object({ type: z21.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. */
+  z21.object({ type: z21.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  /** Mobile access (lot 3), after the island in each snapshot and on every change. Local clients only. */
+  z21.object({ type: z21.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`. */
+  z21.object({ type: z21.literal("message.ack"), rid: z21.string(), outcome: z21.enum(["accepted", "queued", "native", "refused"]), reason: z21.string().optional() }),
+  /** The answer to a `message.read`: the body with its sender, target and time, or the refusal's `reason`. */
+  z21.object({ type: z21.literal("message.body"), id: z21.string(), from: z21.string().optional(), to: z21.string().optional(), at: z21.string().optional(), text: z21.string().optional(), reason: z21.string().optional() }),
+  TaskResultSchema,
+  SessionHandoverResultSchema,
+  ContextPrefsMessageSchema,
+  HandoverResultSchema,
+  TaskUpdatedSchema,
+  RolesListingSchema,
+  TeamsMessageSchema,
+  TeamUpdatedSchema,
+  TeamLaunchedSchema,
+  TeamFailedSchema,
+  TeamSavedSchema,
+  z21.object({
+    type: z21.literal("error"),
+    message: z21.string(),
+    id: z21.string().optional(),
+    /** Le type du message client refusé. */
+    request: z21.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: z21.string().optional()
+  })
+]);
+var MESSAGE_MAX = 2e4;
+var SUMMARY_MAX = 500;
+var launchRows = z21.array(z21.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var ClientMessageSchema = z21.discriminatedUnion("type", [
+  z21.object({ type: z21.literal("chat.route"), qid: z21.string().min(1).max(100), text: z21.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+  DocumentReadSchema,
+  AttachmentPutSchema,
+  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`. */
+  z21.object({
+    type: z21.literal("session.launch"),
+    tool: ToolSchema,
+    cwd: z21.string().min(1),
+    name: z21.string().optional(),
+    prompt: z21.string().optional(),
+    continue: z21.boolean().optional(),
+    qid: z21.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: z21.array(z21.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: z21.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`. */
+  z21.object({
+    type: z21.literal("folder.list"),
+    path: z21.string().optional(),
+    /** Routing by the fleet, removed before the message reaches the daemon. */
+    machineId: z21.string().optional(),
+    /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
+    requestId: z21.string().min(1).max(100).optional()
+  }),
+  z21.object({
+    type: z21.literal("folder.create"),
+    parent: z21.string().min(1),
+    name: z21.string().min(1),
+    /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
+    machineId: z21.string().optional(),
+    requestId: z21.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. */
+  z21.object({ type: z21.literal("session.answer"), id: z21.string(), requestId: z21.string().min(1).max(200), answers: z21.array(z21.object({ id: z21.string(), selected: z21.array(z21.string().max(2e3)).max(100), text: z21.string().max(2e4).optional() })).max(50), cancel: z21.boolean().optional() }),
+  z21.object({ type: z21.literal("session.reply"), id: z21.string(), text: z21.string(), attachments: z21.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(), steer: z21.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. */
+  z21.object({ type: z21.literal("session.relay"), qid: z21.string().min(1) }),
+  /** Takes the card's queued instruction back out of the queue. */
+  z21.object({ type: z21.literal("session.relay.cancel"), qid: z21.string().min(1) }),
+  /** The chat's generic card (action registry spec §5.1): applies its rows in order (all of them without `rows`), stopping at
+   *  the first failure. `confirmed` says the front asked again; refused without it when a row is destructive. */
+  z21.object({
+    type: z21.literal("chat.act"),
+    rid: z21.string().min(1).max(100),
+    qid: z21.string().min(1),
+    rows: launchRows.optional(),
+    confirmed: z21.literal(true).optional(),
+    /** « Refuser »: each row (session.decide only) answers its session's request with deny, whatever its own decision; never
+     *  confirmed, and allowed on a request shown cut. The rows become `denied`. */
+    deny: z21.literal(true).optional()
+  }),
+  /** « Ignorer » the turn's cards, for every device and for Ledge (who is told at the next question); `undo` opens them
+   *  again (« Revoir »). Refused while one of them is under way. Every client gets the turn's `ignoredAt` through chat.history. */
+  z21.object({ type: z21.literal("chat.ignore"), qid: z21.string().min(1), undo: z21.literal(true).optional() }),
+  /** A registry action run outside the chat (#93, the CLI): the daemon resolves `args` as it does a generic card's row, then
+   *  applies it through its own handler. `by` the session that asks, left out for the user; `confirmed` for a destructive one. */
+  z21.object({
+    type: z21.literal("action.run"),
+    rid: z21.string().min(1).max(100),
+    by: z21.string().min(1).optional(),
+    /** `by`'s key (LEDGE_SESSION_KEY) */
+    key: z21.string().max(128).optional(),
+    action: ActionIdSchema,
+    args: z21.record(z21.unknown()),
+    confirmed: z21.literal(true).optional()
+  }),
+  /** The chat's close card: closes the turn's sessions, `rows` (indexes into its `closes`) or all of them. */
+  z21.object({ type: z21.literal("session.close"), qid: z21.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. */
+  z21.object({
+    type: z21.literal("session.decide"),
+    id: z21.string(),
+    decision: DecisionSchema,
+    note: z21.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: z21.string().max(64).optional() }).optional()
+  }),
+  z21.object({ type: z21.literal("session.focus"), id: z21.string() }),
+  z21.object({ type: z21.literal("session.kill"), id: z21.string() }),
+  /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
+  z21.object({ type: z21.literal("session.interrupt"), id: z21.string(), restoreQueue: z21.boolean().optional() }),
+  /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
+  z21.object({ type: z21.literal("session.dismiss"), id: z21.string() }),
+  /** Puts a session in the archive: it leaves the live list but is kept. */
+  z21.object({ type: z21.literal("session.archive"), id: z21.string() }),
+  /** Takes an archived session back out of the archive, as it was. */
+  z21.object({ type: z21.literal("session.restore"), id: z21.string() }),
+  /** Starts the agent again on an archived session's conversation. */
+  z21.object({ type: z21.literal("session.resume"), id: z21.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. */
+  z21.object({ type: z21.literal("session.model"), id: z21.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  /** Deletes a session for good, archived or not. */
+  z21.object({ type: z21.literal("session.delete"), id: z21.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. */
+  z21.object({ type: z21.literal("session.rename"), id: z21.string(), topic: z21.string().max(500) }),
+  z21.object({ type: z21.literal("session.thread"), id: z21.string() }),
+  z21.object({ type: z21.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). */
+  z21.object({ type: z21.literal("session.event"), id: z21.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z21.string().optional() }),
+  z21.object({ type: z21.literal("session.unregister"), id: z21.string(), exitCode: z21.number().int().nullable() }),
+  z21.object({ type: z21.literal("snapshot.request") }),
+  z21.object({ type: z21.literal("chat.ask"), qid: z21.string().min(1), text: z21.string(), images: z21.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
+  z21.object({ type: z21.literal("chat.cancel"), qid: z21.string().min(1) }),
+  /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
+  z21.object({ type: z21.literal("chat.reset") }),
+  /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
+  z21.object({ type: z21.literal("update.daemon"), version: z21.string().regex(SEMVER) }),
+  /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
+  z21.object({ type: z21.literal("machines.set"), machines: MachinesSchema }),
+  /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
+  z21.object({ type: z21.literal("projects.set"), projects: ProjectsSchema }),
+  /** Replaces the island's settings as a whole; refused unless valid. */
+  z21.object({ type: z21.literal("island.set"), prefs: IslandPrefsSchema }),
+  /** Mobile access (lot 3), local fronts only. A changed `relayUrl` drops the relay session. */
+  z21.object({ type: z21.literal("mobile.set"), enabled: z21.boolean(), relayUrl: RelayUrlSchema }),
+  z21.object({ type: z21.literal("mobile.signin") }),
+  z21.object({ type: z21.literal("mobile.signin.cancel") }),
+  z21.object({ type: z21.literal("mobile.signout") }),
+  /** While the link is offline: try again now. */
+  z21.object({ type: z21.literal("mobile.retry") }),
+  z21.object({ type: z21.literal("mobile.pairing.approve"), id: z21.string().min(1).max(100) }),
+  z21.object({ type: z21.literal("mobile.pairing.deny"), id: z21.string().min(1).max(100) }),
+  /** `id`: the device's fingerprint. */
+  z21.object({ type: z21.literal("mobile.device.revoke"), id: z21.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. */
+  z21.object({ type: z21.literal("session.message"), rid: z21.string().min(1), from: z21.string().min(1), to: z21.string().min(1), text: z21.string().min(1).max(MESSAGE_MAX), summary: z21.string().max(SUMMARY_MAX).optional(), intercept: z21.boolean().optional() }),
+  /** `ledge read <id>`: a message's whole body, for its receiver or its sender (`by`, a session id). */
+  z21.object({ type: z21.literal("message.read"), id: z21.string().min(1).max(40), by: z21.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/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 z22 } from "zod";
+var SEALED_MAX = 1048576;
+var RelayPeerSchema = z22.union([z22.literal("pc"), z22.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
+var RelayClientMessageSchema = z22.object({
+  type: z22.literal("send"),
+  to: RelayPeerSchema,
+  body: z22.string().max(SEALED_MAX)
+});
+var RelayServerMessageSchema = z22.discriminatedUnion("type", [
+  z22.object({ type: z22.literal("welcome"), accountId: z22.string(), self: RelayPeerSchema, online: z22.array(RelayPeerSchema) }),
+  z22.object({ type: z22.literal("deliver"), from: RelayPeerSchema, body: z22.string() }),
+  z22.object({ type: z22.literal("presence"), peer: RelayPeerSchema, online: z22.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.
+   */
+  z22.object({
+    type: z22.literal("error"),
+    code: z22.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
+    to: RelayPeerSchema.optional()
+  })
+]);
+var PAIR_LABEL_MAX = 40;
+var KeyB64 = z22.string().regex(/^[A-Za-z0-9_-]{87}$/);
+var Nonce = z22.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var Fingerprint = z22.string().regex(/^[A-Za-z0-9_-]{22}$/);
+var SealedFrameSchema = z22.discriminatedUnion("k", [
+  /** `e` is the ephemeral key, `f` the fingerprint of the sender's static key. */
+  z22.object({ k: z22.literal("hello"), e: KeyB64, f: Fingerprint }),
+  z22.object({ k: z22.literal("msg"), s: z22.string() }),
+  z22.object({ k: z22.literal("pair_commit"), c: Nonce, label: z22.string().trim().min(1).max(PAIR_LABEL_MAX) }),
+  z22.object({ k: z22.literal("pair_offer"), pc: KeyB64, n: Nonce }),
+  z22.object({ k: z22.literal("pair_reveal"), d: KeyB64, n: Nonce }),
+  z22.object({ k: z22.literal("pair_ok") }),
+  z22.object({ k: z22.literal("pair_no") }),
+  z22.object({ k: z22.literal("denied") }),
+  z22.object({ k: z22.literal("rekey") })
+]);
+
+// ../protocol/src/relayAuth.ts
+import { z as z23 } from "zod";
+var RELAY_CLOSE_SIGNED_OUT = 4001;
+var DeviceStartResponseSchema = z23.object({
+  deviceCode: z23.string().min(1),
+  userCode: z23.string().min(1),
+  verificationUri: z23.string().min(1),
+  expiresIn: z23.number().int().positive(),
+  interval: z23.number().int().positive()
+});
+var DevicePollResponseSchema = z23.discriminatedUnion("status", [
+  z23.object({ status: z23.literal("pending") }),
+  z23.object({ status: z23.literal("slow_down"), interval: z23.number().int().positive() }),
+  /** `token` is the relay session token, shown this once only. */
+  z23.object({ status: z23.literal("ok"), token: z23.string().min(1), accountId: z23.string().min(1), login: z23.string().min(1) }),
+  z23.object({ status: z23.literal("expired") }),
+  z23.object({ status: z23.literal("denied") }),
+  z23.object({ status: z23.literal("not_allowed") })
+]);
+var DeviceRevokeResponseSchema = z23.object({ revoked: z23.number().int().min(0) });
+var MeResponseSchema = z23.object({
+  accountId: z23.string().min(1),
+  login: z23.string().min(1),
+  peer: RelayPeerSchema,
+  kind: z23.enum(["pc", "device"])
+});
+
+// ../protocol/src/phone.ts
+import { z as z25 } from "zod";
+
+// ../protocol/src/push.ts
+import { z as z24 } from "zod";
+var B64U = z24.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 = z24.object({
+  endpoint: z24.string().url().max(1024),
+  body: B64U.max(5462),
+  ttl: z24.number().int().min(0).max(86400),
+  urgency: z24.enum(["normal", "high"]),
+  topic: z24.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+});
+var PushSendResultSchema = z24.object({
+  result: z24.enum(["sent", "gone", "failed"]),
+  status: z24.number().int().optional()
+});
+var PushSubscriptionSchema = z24.object({
+  endpoint: z24.string().url().max(1024).refine(pushEndpointAllowed),
+  keys: z24.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
+});
+var PushPayloadSchema = z24.object({
+  v: z24.literal(1),
+  kind: z24.enum(["request", "question", "finished", "chat"]),
+  title: z24.string().max(80),
+  body: z24.string().max(120),
+  url: z24.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
+  badge: z24.number().int().min(0).max(999),
+  tag: z24.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 = z25.enum(["low", "high"]);
+var RiskReasonSchema = z25.enum(["question", "read_only_command", "edit_inside_folder", "pushes", "destroys", "deploys", "publishes", "pipes_to_shell", "network", "writes_outside_folder", "sensitive_path", "unsafe_flag", "shell_syntax", "script", "plan", "unknown"]);
+var OperationIdSchema = z25.string().uuid();
+var OperationStatusSchema = z25.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z25.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired"]);
+var CapabilitiesSchema = z25.object({
+  /** A question can be answered in free text. */
+  freeTextAnswer: z25.boolean(),
+  /** The session's accept/deny can be typed; absent = true. */
+  decide: z25.boolean().optional(),
+  /** OMP's dialog questions can be answered from the phone; absent = false. */
+  questions: z25.boolean().optional()
+});
+var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
+var CapabilitiesByToolSchema = z25.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z25.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z25.literal(true).optional() });
+var 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: z25.boolean(), handover: z25.object({ state: HandoverStateSchema, toName: z25.string().max(80).optional() }).strict().optional() });
+var B64U2 = z25.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z25.object({
+  id: B64U2.max(1366),
+  publicKey: B64U2.max(2048),
+  alg: z25.union([z25.literal(-7), z25.literal(-257)]),
+  clientDataJSON: B64U2.max(4096),
+  authenticatorData: B64U2.max(4096),
+  transports: z25.array(z25.string().max(20)).max(8).optional()
+});
+var AssertionSchema = z25.object({
+  id: B64U2.max(1366),
+  clientDataJSON: B64U2.max(4096),
+  authenticatorData: B64U2.max(4096),
+  signature: B64U2.max(1024)
+});
+var ConfirmPurposeSchema = z25.enum(["register", "decide", "launch", "close", "act"]);
+var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
+var PhoneChatProposalSchema = z25.object({
+  project: z25.string().max(80),
+  tool: ToolSchema,
+  prompt: z25.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z25.string().optional(),
+  failed: z25.literal(true).optional()
+}).strict();
+var PhoneChatRelaySchema = z25.object({
+  id: z25.string().min(1),
+  name: z25.string(),
+  tool: ToolSchema,
+  text: z25.string().max(TOOL_TEXT_MAX),
+  status: z25.enum(["queued", "sent"]).optional(),
+  sentAt: z25.string().datetime().optional(),
+  failed: z25.literal(true).optional()
+}).strict();
+var PhoneChatCloseSchema = z25.object({
+  id: z25.string().min(1),
+  name: z25.string(),
+  tool: ToolSchema,
+  how: z25.enum(["exit", "killed"]).optional(),
+  closedAt: z25.string().datetime().optional(),
+  failed: z25.literal(true).optional()
+}).strict();
+var PhoneChatTeamSchema = z25.object({
+  project: z25.string().max(80),
+  name: z25.string().max(60),
+  template: z25.string().max(64).optional(),
+  seats: z25.array(z25.object({ role: z25.string().max(40), label: z25.string().max(40), tool: ToolSchema, model: z25.string().max(200).optional(), effort: z25.string().max(20).optional(), autonomy: AutonomySchema.optional() }).strict()).min(1).max(8),
+  teamId: z25.string().max(40).optional(),
+  launchedAt: z25.string().datetime().optional(),
+  failed: z25.literal(true).optional()
+}).strict();
+var PhoneChatTaskSchema = z25.object({
+  to: z25.string().max(80),
+  toName: z25.string().max(80).optional(),
+  title: z25.string().max(200),
+  text: z25.string().max(TOOL_TEXT_MAX).optional(),
+  taskId: z25.string().max(40).optional(),
+  ownerName: z25.string().max(80).optional(),
+  state: z25.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  failed: z25.literal(true).optional()
+}).strict();
+var PhoneChatActionSchema = z25.object({
+  action: z25.string().min(1).max(40),
+  summary: z25.string().max(300),
+  vars: ActionVarsSchema.optional(),
+  detail: z25.string().max(TOOL_TEXT_MAX).optional(),
+  detailCut: z25.literal(true).optional(),
+  risk: ActionRiskSchema,
+  session: z25.string().max(100).optional(),
+  team: z25.string().max(40).optional(),
+  state: ChatActionStateSchema.optional(),
+  doneAt: z25.string().datetime().optional(),
+  code: z25.string().max(40).optional()
+}).strict();
+var PhoneTeamSchema = z25.object({
+  id: z25.string().max(40),
+  name: z25.string().max(60),
+  project: z25.string().max(80).nullable(),
+  state: z25.enum(["active", "resting"]),
+  seats: z25.array(z25.object({ role: z25.string().max(40), sessionId: z25.string().max(100).nullable() }).strict()).max(16),
+  done: z25.number().int().min(0),
+  given: z25.number().int().min(0)
+}).strict();
+var PhoneTaskSchema = z25.object({
+  id: z25.string().max(40),
+  title: z25.string().max(200),
+  owner: z25.string().max(100),
+  ownerName: z25.string().max(80),
+  ownerRole: z25.string().max(40).optional(),
+  team: z25.string().max(40).optional(),
+  teamName: z25.string().max(60).optional(),
+  state: z25.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z25.string().max(TOOL_TEXT_MAX).optional(),
+  cut: z25.literal(true).optional(),
+  at: z25.string(),
+  updatedAt: z25.string(),
+  seen: z25.literal(true).optional()
+}).strict();
+var ChatErrorCodeSchema = z25.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z25.object({
+  qid: OperationIdSchema,
+  question: z25.string().max(MESSAGE_MAX),
+  askedAt: z25.string().datetime(),
+  steps: z25.array(PhoneChatStepSchema).max(50),
+  answer: z25.string().max(THREAD_TEXT_MAX).optional(),
+  answeredAt: z25.string().datetime().optional(),
+  error: ChatErrorCodeSchema.optional(),
+  proposals: z25.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  relay: PhoneChatRelaySchema.optional(),
+  closes: z25.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
+  cut: z25.literal(true).optional(),
+  team: PhoneChatTeamSchema.optional(),
+  tasks: z25.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
+  actions: z25.array(PhoneChatActionSchema).min(1).max(MAX_PROPOSALS).optional(),
+  ignoredAt: z25.string().datetime().optional(),
+  attachments: z25.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
+}).strict();
+var CHAT_HISTORY_BUDGET = 393216;
+var sessionId = z25.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z25.string().min(1).max(64) });
+var CardRowsSchema = z25.array(z25.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var PhoneClientMessageSchema = z25.discriminatedUnion("type", [
+  z25.object({ type: z25.literal("snapshot.request") }),
+  z25.object({ type: z25.literal("session.thread"), id: sessionId }),
+  /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
+  z25.object({ type: z25.literal("session.pending"), id: sessionId }),
+  /** The session whose terminal the phone shows; null when it shows none. */
+  z25.object({ type: z25.literal("session.watch"), id: sessionId.nullable() }),
+  z25.object({ type: z25.literal("session.read"), id: sessionId, at: z25.string().datetime() }),
+  /** Asks for a challenge. One object for both purposes: the gateway refuses a `decide` without `id` and `expect`. */
+  z25.object({ type: z25.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
+  z25.object({ type: z25.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z25.object({
+    type: z25.literal("session.decide"),
+    op: OperationIdSchema,
+    id: sessionId,
+    decision: DecisionSchema,
+    note: z25.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()
+  }),
+  z25.object({
+    type: z25.literal("session.reply"),
+    op: OperationIdSchema,
+    id: sessionId,
+    text: z25.string().max(MESSAGE_MAX),
+    attachments: z25.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`. */
+  z25.object({
+    type: z25.literal("session.answer"),
+    op: OperationIdSchema,
+    id: sessionId,
+    requestId: z25.string().min(1).max(200),
+    answers: z25.array(z25.object({ id: z25.string().max(200), selected: z25.array(z25.string().max(2e3)).max(100), text: z25.string().max(2e4).optional() })).max(50),
+    cancel: z25.literal(true).optional(),
+    expect: PhoneExpectSchema
+  }),
+  z25.object({ type: z25.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  /** The phone drops its passkey from the daemon. */
+  z25.object({ type: z25.literal("device.forget"), op: OperationIdSchema }),
+  /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
+  z25.object({ type: z25.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z25.object({ type: z25.literal("push.unsubscribe"), op: OperationIdSchema }),
+  /** The phone's own chat with Ledge. */
+  z25.object({ type: z25.literal("chat.ask"), qid: OperationIdSchema, text: z25.string().trim().max(MESSAGE_MAX), attachments: z25.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
+  z25.object({ type: z25.literal("chat.cancel"), qid: OperationIdSchema }),
+  z25.object({ type: z25.literal("chat.reset") }),
+  z25.object({ type: z25.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: z25.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
+  AttachmentGetSchema.pick({ type: true, requestId: true, attachment: true, preview: true }),
+  z25.object({ type: z25.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z25.object({ type: z25.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z25.object({ type: z25.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). */
+  z25.object({ type: z25.literal("chat.team"), op: OperationIdSchema, qid: OperationIdSchema, assertion: AssertionSchema.optional() }),
+  /** A row of the turn's task card: given by Ledge. */
+  z25.object({ type: z25.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z25.number().int().min(0).max(MAX_PROPOSALS - 1) }),
+  /** Rows of the turn's generic card (action registry spec §5): `confirmed` as the local `chat.act`; a row whose action asks
+   *  for a device check (`phone`) needs one assertion, purpose `act`, over the turn. */
+  z25.object({
+    type: z25.literal("chat.act"),
+    op: OperationIdSchema,
+    qid: OperationIdSchema,
+    rows: CardRowsSchema.optional(),
+    confirmed: z25.literal(true).optional(),
+    assertion: AssertionSchema.optional(),
+    /** « Refuser », as the local `chat.act`: no passkey, no confirmation. */
+    deny: z25.literal(true).optional()
+  }),
+  /** « Ignorer » the turn's cards, or `undo` (« Revoir »), as the local `chat.ignore`. */
+  z25.object({ type: z25.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z25.literal(true).optional() }),
+  /** « Reprendre » a resting team. */
+  z25.object({ type: z25.literal("team.resume"), op: OperationIdSchema, team: z25.string().min(1).max(40) }),
+  /** Puts a closed task Ledge gave away from « À traiter ». */
+  z25.object({ type: z25.literal("task.seen"), op: OperationIdSchema, task: z25.string().min(1).max(40) }),
+  /** Whether the phone's app is in front: a device that is visible gets no push. */
+  z25.object({ type: z25.literal("presence"), visible: z25.boolean() })
+]);
+var PhoneServerMessageSchema = z25.discriminatedUnion("type", [
+  z25.object({ type: z25.literal("snapshot"), protocol: z25.literal(PHONE_PROTOCOL), sessions: z25.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z25.object({ version: z25.string(), name: z25.string().max(40), boot: z25.string().uuid().optional() }), device: z25.object({ confirm: z25.boolean(), push: z25.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z25.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  z25.object({ type: z25.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z25.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z25.number().int().positive() }),
+  z25.object({ type: z25.literal("session.updated"), session: PhoneSessionSchema }),
+  z25.object({ type: z25.literal("session.removed"), id: z25.string() }),
+  /** `pending.cut` is set when even this body was shortened. */
+  z25.object({ type: z25.literal("session.pending"), id: z25.string(), pending: PhonePendingSchema }),
+  z25.object({ type: z25.literal("session.preview"), id: z25.string(), lines: z25.array(z25.string()) }),
+  /** `cut`: the ids of the items shortened; `more`: older items were left out. */
+  z25.object({ type: z25.literal("session.thread"), id: z25.string(), items: z25.array(ThreadItemSchema), cut: z25.array(z25.string()), more: z25.boolean() }),
+  z25.object({ type: z25.literal("session.thread.item"), id: z25.string(), item: ThreadItemSchema, cut: z25.literal(true).optional() }),
+  z25.object({ type: z25.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
+  z25.object({ type: z25.literal("chat.history"), turns: z25.array(PhoneChatTurnSchema).max(50) }),
+  z25.object({ type: z25.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  /** The whole text so far, not an increment. */
+  z25.object({ type: z25.literal("chat.delta"), qid: OperationIdSchema, text: z25.string().max(THREAD_TEXT_MAX) }),
+  z25.object({ type: z25.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z25.object({ type: z25.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
+  /** The live teams, after each snapshot and on every change. */
+  z25.object({ type: z25.literal("teams"), teams: z25.array(PhoneTeamSchema).max(50) }),
+  /** The tasks Ledge gave, open or closed lately, after each snapshot; then each change. */
+  z25.object({ type: z25.literal("tasks"), tasks: z25.array(PhoneTaskSchema).max(200) }),
+  z25.object({ type: z25.literal("task.updated"), task: PhoneTaskSchema }),
+  AttachmentStoredSchema,
+  AttachmentDataSchema,
+  AttachmentErrorSchema,
+  /** Never carries free text. */
+  z25.object({ type: z25.literal("error"), code: z25.enum(["invalid", "unknown_session", "too_large"]), request: z25.string().max(40).optional() })
+]);
+
+// src/auth.ts
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "crypto";
+import { chmod, link, mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { readFileSync } from "fs";
+import { dirname } from "path";
+var TOKEN_RE = /^[0-9a-f]{64}$/;
+var DAEMON_PROTOCOL_PREFIX = "ledge.";
+function isDaemonToken(value) {
+  return TOKEN_RE.test(value);
+}
+function tokenEquals(presented, expected) {
+  const a = createHash("sha256").update(presented.slice(0, 256), "utf8").digest();
+  const b = createHash("sha256").update(expected, "utf8").digest();
+  return timingSafeEqual(a, b);
+}
+function hostAllowed(hostHeader) {
+  const raw = Array.isArray(hostHeader) ? hostHeader[0] : hostHeader;
+  if (!raw || raw.length > 255) return false;
+  const host = raw.trim().toLowerCase();
+  if (!host || host.includes(" ") || host.endsWith(".")) return false;
+  let name;
+  if (host.startsWith("[")) {
+    const end = host.indexOf("]");
+    if (end < 0) return false;
+    name = host.slice(1, end);
+    const rest = host.slice(end + 1);
+    if (rest !== "" && !/^:\d{1,5}$/.test(rest)) return false;
+  } else {
+    const colon = host.lastIndexOf(":");
+    if (colon >= 0) {
+      if (!/^\d{1,5}$/.test(host.slice(colon + 1))) return false;
+      name = host.slice(0, colon);
+    } else name = host;
+  }
+  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;
+}
+var SESSION_KEY_VAR = "LEDGE_SESSION_KEY";
+function sessionKey(id, token = readDaemonToken()) {
+  return token ? createHmac("sha256", token).update(`ledge-session:${id}`).digest("hex") : void 0;
+}
+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,
+  autonomyArgs,
+  ompApprovalFor,
+  SessionSchema,
+  backendOf,
+  isArchived,
+  ModelIdSchema,
+  EffortSchema,
+  extractProposal,
+  parseRelayBlock,
+  parseCloseBlock,
+  parseTeamBlock,
+  parseTaskBlock,
+  parseProjectBlock,
+  RoleIdSchema,
+  ROLE_LABEL_MAX,
+  ROLE_PROMPT_MAX,
+  RoleSchema,
+  SeatsSchema,
+  TeamNameSchema,
+  TeamSchema,
+  isTeamLive,
+  NOTE_MAX,
+  NOTE_NOT_TYPED,
+  offers,
+  pendingKey,
+  TASK_TITLE_MAX,
+  TASK_TEXT_MAX,
+  LEDGE_GIVER,
+  transmissions,
+  givenByLedge,
+  taskClosed,
+  ACTIONS,
+  actionById,
+  riskOf,
+  LEGACY_FENCE_ACTION,
+  parseActionBlock,
+  NEVER_PROPOSED,
+  MAX_PROPOSALS,
+  DETAIL_MAX,
+  ACTION_ERROR_CODES,
+  ChatTurnSchema,
+  proposalRows,
+  DOCUMENT_MAX_BYTES,
+  SshAliasSchema,
+  MachinesSchema,
+  IslandPrefsSchema,
+  PROJECT_COLORS,
+  ProjectsSchema,
+  DEFAULT_PROJECTS,
+  projectOf,
+  RouteResultSchema,
+  DEFAULT_RELAY_URL,
+  MobileConfigSchema,
+  PROTOCOL_PORT,
+  RefusalCodeSchema,
+  RecentSchema,
+  MESSAGE_MAX,
+  SUMMARY_MAX,
+  parseClientMessage,
+  parseServerMessage,
+  NAMES,
+  pickName,
+  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,
+  tokenEquals,
+  hostAllowed,
+  requestAuthorized,
+  selectDaemonProtocol,
+  ensureDaemonToken,
+  SESSION_KEY_VAR,
+  sessionKey,
+  readDaemonToken
+};