@paradow/ledge 0.12.1 → 0.14.0

package/dist/cli/{chunk-VY45MACP.js → chunk-5LVPB3ET.js}

@@ -1,11 +1,20 @@
 import {
   paths
-} from "./chunk-FGOFRWIB.js";
+} from "./chunk-QBJEUZYW.js";
 
 // ../protocol/src/session.ts
 import { z } from "zod";
-var ToolSchema = z.enum(["claude", "codex", "cursor"]);
+var ToolSchema = z.enum(["claude", "codex", "cursor", "omp"]);
+var OmpApprovalSchema = z.enum(["always-ask", "write", "yolo"]);
+var BackendSchema = z.enum(["tmux", "omp-rpc"]);
 var SessionStateSchema = z.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
+var AskQuestionSchema = z.object({
+  id: z.string(),
+  question: z.string(),
+  header: z.string().optional(),
+  multi: z.boolean().optional(),
+  options: z.array(z.object({ label: z.string(), description: z.string().optional() }))
+});
 var PendingSchema = z.object({
   kind: z.enum(["question", "permission", "plan", "diff"]),
   text: z.string(),
@@ -15,7 +24,11 @@ var PendingSchema = z.object({
   options: z.array(z.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
   optionDetails: z.array(z.string()).optional(),
-  source: z.enum(["hook", "pane"]),
+  /** `rpc`: the harness's own protocol asked (OMP): answered on its request id, never by typing. */
+  source: z.enum(["hook", "pane", "rpc"]),
+  /** OMP: every question of one `ask` call, answered together with `session.answer`; `requestId` is the dialog it answers. */
+  questions: z.array(AskQuestionSchema).optional(),
+  requestId: z.string().optional(),
   /** Set when the request comes from a helper (subagent): it is routed through its parent. */
   helperId: z.string().optional(),
   /** For a helper-routed request: the state the parent returns to once it is answered (main thread may stop meanwhile). */
@@ -60,9 +73,13 @@ var SessionSchema = z.object({
   /** 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: z.string().optional(),
   tmuxSession: z.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: z.array(HelperSchema).default([]),
+  /** OMP: the instructions waiting in its own queue (typed while it works), as it reports them; left out when none. */
+  queue: z.array(z.object({ text: z.string(), mode: z.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: z.object({ id: z.string(), to: z.string(), peer: z.string().optional(), summary: z.string(), at: z.string().datetime() }).optional(),
@@ -72,8 +89,14 @@ var SessionSchema = z.object({
   /** The model and effort Ledge launched the agent with (#58); left out, the agent's own default. */
   model: z.string().optional(),
   effort: z.string().optional(),
+  /** OMP: the approval mode it was launched with, kept by a resume; left out, `always-ask`. */
+  approval: OmpApprovalSchema.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: z.object({ model: z.string().optional(), effort: z.string().optional() }).optional(),
   /** The agent's own session id when Ledge chose it at launch (Claude Code `--session-id`). */
   agentSessionId: z.string().optional(),
+  /** OMP: the exact journal file of the conversation, what a resume names (never "the latest of the folder"). */
+  agentSessionFile: z.string().optional(),
   /** The agent's transcript: the latest one a hook named (it follows /clear and --resume), else the one the launch implies. */
   transcriptPath: z.string().optional(),
   exitCode: z.number().int().nullable().optional(),
@@ -85,12 +108,15 @@ var SessionSchema = z.object({
   /** When the session was last taken out of the archive: the poller's retirement clock restarts from it, not from `exitedAt`. */
   restoredAt: z.string().datetime().optional()
 });
+function backendOf(s) {
+  return s.backend ?? "tmux";
+}
 function isArchived(s) {
   return s.archivedAt !== void 0;
 }
 
 // ../protocol/src/messages.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // ../protocol/src/chat.ts
 import { z as z2 } from "zod";
@@ -279,8 +305,9 @@ var IslandScaleSchema = z10.union([z10.literal("auto"), z10.literal(1), z10.lite
 var IslandPrefsSchema = z10.object({
   /** Shown at the top of the screen; hidden, Desktop still notifies. */
   visible: z10.boolean(),
-  /** The primary screen, or the first other one. */
-  screen: z10.enum(["primary", "second"]),
+  /** `primary` (whichever it is after a reconfiguration), or a monitor's id as the shell lists it (`list_monitors`: the OS
+   *  name, `#index` without one). `second`, written by older fronts, is the first monitor that is not the primary. */
+  screen: z10.string().trim().min(1).max(200),
   position: z10.enum(["center", "left", "right"]),
   /** A strip under a maximised window. */
   discreet: z10.boolean(),
@@ -406,7 +433,9 @@ 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"] }
+  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);
@@ -427,59 +456,125 @@ function pendingKey(p) {
   return cyrb53(s, 0) + cyrb53(s, 1);
 }
 
+// ../protocol/src/mobile.ts
+import { z as z14 } from "zod";
+var DEFAULT_RELAY_URL = "https://server.ledge.paradow.dev";
+var RelayUrlSchema = z14.string().transform((v, ctx) => {
+  const bad = () => {
+    ctx.addIssue({ code: z14.ZodIssueCode.custom, message: "invalid relay URL" });
+    return z14.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 = z14.object({ enabled: z14.boolean(), relayUrl: RelayUrlSchema });
+var MobileLinkStateSchema = z14.discriminatedUnion("state", [
+  z14.object({ state: z14.literal("off") }),
+  z14.object({ state: z14.literal("connecting") }),
+  z14.object({ state: z14.literal("online") }),
+  z14.object({ state: z14.literal("offline"), retryAt: z14.string().datetime(), error: z14.string() }),
+  z14.object({ state: z14.literal("signed_out"), reason: z14.enum(["other_pc", "session_invalid"]) }),
+  /** The mobile service did not start (a broken mobile.json, a missing key store): nothing is linked until the daemon restarts. */
+  z14.object({ state: z14.literal("unavailable"), error: z14.string().max(200) })
+]);
+var MobilePairingSchema = z14.object({
+  id: z14.string(),
+  label: z14.string(),
+  code: z14.string().nullable(),
+  expiresAt: z14.string().datetime(),
+  state: z14.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
+});
+var MobileStateSchema = z14.object({
+  enabled: z14.boolean(),
+  relayUrl: z14.string(),
+  account: z14.object({ login: z14.string(), accountId: z14.string() }).nullable(),
+  signin: z14.object({ userCode: z14.string(), verificationUri: z14.string(), expiresAt: z14.string().datetime() }).nullable(),
+  /** The last sign-in that did not end with a session; cleared by the next one. */
+  signinError: z14.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
+  link: MobileLinkStateSchema,
+  devices: z14.array(z14.object({ id: z14.string(), label: z14.string(), approvedAt: z14.string(), online: z14.boolean(), lastSeenAt: z14.string().optional() })),
+  pairings: z14.array(MobilePairingSchema)
+});
+
 // ../protocol/src/messages.ts
 var PROTOCOL_PORT = 47831;
-var SessionEventSchema = z14.object({
-  name: z14.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed"]),
-  at: z14.string().datetime(),
-  source: z14.enum(["hook", "pane", "daemon"]),
-  tool: z14.string().optional(),
-  text: z14.string().optional(),
-  options: z14.array(z14.string()).optional(),
+var RefusalCodeSchema = z15.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid"]);
+var SessionEventSchema = z15.object({
+  name: z15.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
+  at: z15.string().datetime(),
+  source: z15.enum(["hook", "pane", "daemon"]),
+  tool: z15.string().optional(),
+  text: z15.string().optional(),
+  options: z15.array(z15.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z14.array(z14.string()).optional(),
-  kind: z14.enum(["question", "permission", "plan", "diff"]).optional(),
+  optionDetails: z15.array(z15.string()).optional(),
+  kind: z15.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: z14.string().optional(),
-  exitCode: z14.number().int().nullable().optional(),
-  helperId: z14.string().optional(),
+  body: z15.string().optional(),
+  exitCode: z15.number().int().nullable().optional(),
+  helperId: z15.string().optional(),
   /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z14.string().optional(),
+  task: z15.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z14.boolean().optional(),
+  interrupt: z15.boolean().optional(),
+  /** QueueUpdate: OMP's queue as it stands. */
+  queue: z15.array(z15.object({ text: z15.string(), mode: z15.enum(["steer", "follow_up"]) })).optional(),
+  /** AgentMessage: the harness's own message, its text so far (`streaming`) or whole. `messageId` is unique for the session's life. */
+  messageId: z15.string().optional(),
+  streaming: z15.boolean().optional(),
+  /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
+  requestId: z15.string().optional(),
+  questions: z15.array(AskQuestionSchema).optional(),
+  /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
+  streamed: z15.boolean().optional(),
   /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
-  toolUseId: z14.string().optional(),
+  toolUseId: z15.string().optional(),
   /** The tool's input as the harness gave it, every string capped by the hook. */
-  toolInput: z14.record(z14.string(), z14.unknown()).optional(),
+  toolInput: z15.record(z15.string(), z15.unknown()).optional(),
   /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z14.string().optional(),
-  durationMs: z14.number().nonnegative().optional(),
+  output: z15.string().optional(),
+  durationMs: z15.number().nonnegative().optional(),
   /** PostToolUseFailure: the harness's error message. */
-  error: z14.string().optional(),
+  error: z15.string().optional(),
   /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
-  transcriptPath: z14.string().optional(),
+  transcriptPath: z15.string().optional(),
   /** Decided: what was chosen when the daemon knows it. */
   decision: DecisionSchema.optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
-  agentSessionId: z14.string().optional()
+  agentSessionId: z15.string().optional()
 });
-var RecentSchema = z14.object({ cwd: z14.string().min(1), project: z14.string().min(1), lastAt: z14.string().datetime() });
+var RecentSchema = z15.object({ cwd: z15.string().min(1), project: z15.string().min(1), lastAt: z15.string().datetime() });
 var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z14.object({
-  version: z14.string(),
-  install: z14.enum(["npm", "git", "unknown"]),
-  systemd: z14.boolean(),
-  manual: z14.string().optional(),
-  routing: z14.boolean().optional(),
-  archive: z14.boolean().optional(),
+var DaemonInfoSchema = z15.object({
+  version: z15.string(),
+  install: z15.enum(["npm", "git", "unknown"]),
+  systemd: z15.boolean(),
+  manual: z15.string().optional(),
+  routing: z15.boolean().optional(),
+  archive: z15.boolean().optional(),
   /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
-  models: z14.boolean().optional(),
+  models: z15.boolean().optional(),
+  /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
+  omp: z15.boolean().optional(),
+  /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
+  modelSwitch: z15.boolean().optional(),
+  /** Takes `approval` on an OMP `session.launch` (auto mode). */
+  ompApproval: z15.boolean().optional(),
   /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
-  home: z14.string().optional()
+  home: z15.string().optional(),
+  mobile: z15.boolean().optional()
 });
-var UpdateFailureSchema = z14.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("chat.routed"), qid: z14.string(), result: RouteResultSchema }),
+var UpdateFailureSchema = z15.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("chat.routed"), qid: z15.string(), result: RouteResultSchema }),
   DocumentContentSchema,
   DocumentErrorSchema,
   ReposInfoSchema,
@@ -488,62 +583,66 @@ var ServerMessageSchema = z14.discriminatedUnion("type", [
   /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
    *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
    *  from daemons older than the auto-update. */
-  z14.object({ type: z14.literal("snapshot"), sessions: z14.array(SessionSchema), recents: z14.array(RecentSchema).optional(), launcher: z14.array(z14.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
-  z14.object({ type: z14.literal("session.updated"), session: SessionSchema }),
-  z14.object({ type: z14.literal("session.removed"), id: z14.string() }),
-  z14.object({ type: z14.literal("session.preview"), id: z14.string(), lines: z14.array(z14.string()) }),
+  z15.object({ type: z15.literal("snapshot"), sessions: z15.array(SessionSchema), recents: z15.array(RecentSchema).optional(), launcher: z15.array(z15.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z15.object({ type: z15.literal("session.updated"), session: SessionSchema }),
+  /** OMP: the instructions taken back from its queue by an interrupt that restores it; the asker puts them back in its draft. */
+  z15.object({ type: z15.literal("session.queue.restored"), id: z15.string(), texts: z15.array(z15.string()) }),
+  z15.object({ type: z15.literal("session.removed"), id: z15.string() }),
+  z15.object({ type: z15.literal("session.preview"), id: z15.string(), lines: z15.array(z15.string()) }),
   /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
-  z14.object({ type: z14.literal("session.thread"), id: z14.string(), items: z14.array(ThreadItemSchema) }),
-  z14.object({ type: z14.literal("session.thread.item"), id: z14.string(), item: ThreadItemSchema }),
+  z15.object({ type: z15.literal("session.thread"), id: z15.string(), items: z15.array(ThreadItemSchema) }),
+  z15.object({ type: z15.literal("session.thread.item"), id: z15.string(), item: ThreadItemSchema }),
   /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
-  z14.object({ type: z14.literal("session.launched"), id: z14.string() }),
-  z14.object({ type: z14.literal("recents"), recents: z14.array(RecentSchema) }),
+  z15.object({ type: z15.literal("session.launched"), id: z15.string() }),
+  z15.object({ type: z15.literal("recents"), recents: z15.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. */
-  z14.object({
-    type: z14.literal("folder.listing"),
-    path: z14.string(),
-    parent: z14.string().nullable(),
-    entries: z14.array(z14.string()),
-    error: z14.string().optional(),
+  z15.object({
+    type: z15.literal("folder.listing"),
+    path: z15.string(),
+    parent: z15.string().nullable(),
+    entries: z15.array(z15.string()),
+    error: z15.string().optional(),
     /** The request this answers, when it carried one. */
-    requestId: z14.string().optional(),
+    requestId: z15.string().optional(),
     /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
-    repos: z14.array(z14.object({ name: z14.string(), branch: z14.string() })).optional()
+    repos: z15.array(z15.object({ name: z15.string(), branch: z15.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. */
-  z14.object({ type: z14.literal("chat.step"), qid: z14.string(), step: ChatStepSchema }),
-  z14.object({ type: z14.literal("chat.delta"), qid: z14.string(), text: z14.string() }),
-  z14.object({ type: z14.literal("chat.done"), qid: z14.string(), text: z14.string(), at: z14.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
-  z14.object({ type: z14.literal("chat.error"), qid: z14.string(), message: z14.string() }),
-  z14.object({ type: z14.literal("chat.history"), turns: z14.array(ChatTurnSchema) }),
+  z15.object({ type: z15.literal("chat.step"), qid: z15.string(), step: ChatStepSchema }),
+  z15.object({ type: z15.literal("chat.delta"), qid: z15.string(), text: z15.string() }),
+  z15.object({ type: z15.literal("chat.done"), qid: z15.string(), text: z15.string(), at: z15.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), projectProposal: ChatProjectProposalSchema.optional() }),
+  z15.object({ type: z15.literal("chat.error"), qid: z15.string(), message: z15.string() }),
+  z15.object({ type: z15.literal("chat.history"), turns: z15.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
-  z14.object({ type: z14.literal("update.progress"), version: z14.string(), step: z14.enum(["installing", "restarting"]) }),
+  z15.object({ type: z15.literal("update.progress"), version: z15.string(), step: z15.enum(["installing", "restarting"]) }),
   /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
-  z14.object({ type: z14.literal("update.failed"), version: z14.string(), reason: UpdateFailureSchema, detail: z14.string().optional(), command: z14.string().optional() }),
+  z15.object({ type: z15.literal("update.failed"), version: z15.string(), reason: UpdateFailureSchema, detail: z15.string().optional(), command: z15.string().optional() }),
   /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z14.object({ type: z14.literal("machines"), machines: MachinesSchema }),
+  z15.object({ type: z15.literal("machines"), machines: MachinesSchema }),
   /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
-  z14.object({ type: z14.literal("projects"), projects: ProjectsSchema }),
+  z15.object({ type: z15.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. */
-  z14.object({ type: z14.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  z15.object({ type: z15.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  /** Mobile access (lot 3), after the island in each snapshot and on every change. Local clients only. */
+  z15.object({ type: z15.literal("mobile"), state: MobileStateSchema }),
   /** 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`. */
-  z14.object({ type: z14.literal("message.ack"), rid: z14.string(), outcome: z14.enum(["accepted", "queued", "native", "refused"]), reason: z14.string().optional() }),
-  z14.object({
-    type: z14.literal("error"),
-    message: z14.string(),
-    id: z14.string().optional(),
+  z15.object({ type: z15.literal("message.ack"), rid: z15.string(), outcome: z15.enum(["accepted", "queued", "native", "refused"]), reason: z15.string().optional() }),
+  z15.object({
+    type: z15.literal("error"),
+    message: z15.string(),
+    id: z15.string().optional(),
     /** Le type du message client refusé. */
-    request: z14.string().optional(),
+    request: z15.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: z14.string().optional()
+    code: z15.string().optional()
   })
 ]);
 var MESSAGE_MAX = 2e4;
 var SUMMARY_MAX = 500;
-var ClientMessageSchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("chat.route"), qid: z14.string().min(1).max(100), text: z14.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+var ClientMessageSchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("chat.route"), qid: z15.string().min(1).max(100), text: z15.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
   ReposInspectSchema,
   ReposScanSchema,
@@ -552,92 +651,112 @@ var ClientMessageSchema = z14.discriminatedUnion("type", [
    *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
    *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields
    *  but `rows`, `model` and `effort`. */
-  z14.object({
-    type: z14.literal("session.launch"),
+  z15.object({
+    type: z15.literal("session.launch"),
     tool: ToolSchema,
-    cwd: z14.string().min(1),
-    name: z14.string().optional(),
-    prompt: z14.string().optional(),
-    continue: z14.boolean().optional(),
-    qid: z14.string().min(1).optional(),
+    cwd: z15.string().min(1),
+    name: z15.string().optional(),
+    prompt: z15.string().optional(),
+    continue: z15.boolean().optional(),
+    qid: z15.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: z14.array(z14.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice").optional(),
+    rows: z15.array(z15.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice").optional(),
     /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
-    dirs: z14.array(z14.string().min(1)).max(20).optional(),
+    dirs: z15.array(z15.string().min(1)).max(20).optional(),
     /** The agent's model and effort (#58), the agent's own default when left out; with `qid`, for every row launched. */
     model: ModelIdSchema.optional(),
     effort: EffortSchema.optional(),
+    /** OMP only: its approval mode, `always-ask` when left out. */
+    approval: OmpApprovalSchema.optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z14.string().optional()
+    machineId: z15.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`. */
-  z14.object({
-    type: z14.literal("folder.list"),
-    path: z14.string().optional(),
+  z15.object({
+    type: z15.literal("folder.list"),
+    path: z15.string().optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z14.string().optional(),
+    machineId: z15.string().optional(),
     /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
-    requestId: z14.string().min(1).max(100).optional()
+    requestId: z15.string().min(1).max(100).optional()
   }),
-  z14.object({
-    type: z14.literal("folder.create"),
-    parent: z14.string().min(1),
-    name: z14.string().min(1),
+  z15.object({
+    type: z15.literal("folder.create"),
+    parent: z15.string().min(1),
+    name: z15.string().min(1),
     /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
-    machineId: z14.string().optional(),
-    requestId: z14.string().min(1).max(100).optional()
+    machineId: z15.string().optional(),
+    requestId: z15.string().min(1).max(100).optional()
   }),
-  z14.object({ type: z14.literal("session.reply"), id: z14.string(), text: z14.string().min(1) }),
+  /** `steer`: OMP only, redirect the turn running now instead of queueing the text after it. */
+  /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order (`selected` labels, and/or free `text`); `cancel` declines it. */
+  z15.object({ type: z15.literal("session.answer"), id: z15.string(), requestId: z15.string().min(1).max(200), answers: z15.array(z15.object({ id: z15.string(), selected: z15.array(z15.string().max(2e3)).max(100), text: z15.string().max(2e4).optional() })).max(50), cancel: z15.boolean().optional() }),
+  z15.object({ type: z15.literal("session.reply"), id: z15.string(), text: z15.string().min(1), steer: z15.boolean().optional() }),
   /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
-  z14.object({ type: z14.literal("session.relay"), qid: z14.string().min(1) }),
+  z15.object({ type: z15.literal("session.relay"), qid: z15.string().min(1) }),
   /** Takes the card's queued instruction back out of the queue. */
-  z14.object({ type: z14.literal("session.relay.cancel"), qid: z14.string().min(1) }),
+  z15.object({ type: z15.literal("session.relay.cancel"), qid: z15.string().min(1) }),
   /** `always` and `note` only where the harness offers them (`offers`); a note goes with `deny`, for the agent to read. */
-  z14.object({
-    type: z14.literal("session.decide"),
-    id: z14.string(),
+  z15.object({
+    type: z15.literal("session.decide"),
+    id: z15.string(),
     decision: DecisionSchema,
-    note: z14.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z15.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: z14.string().max(64).optional() }).optional()
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z15.string().max(64).optional() }).optional()
   }),
-  z14.object({ type: z14.literal("session.focus"), id: z14.string() }),
-  z14.object({ type: z14.literal("session.kill"), id: z14.string() }),
-  z14.object({ type: z14.literal("session.interrupt"), id: z14.string() }),
+  z15.object({ type: z15.literal("session.focus"), id: z15.string() }),
+  z15.object({ type: z15.literal("session.kill"), id: z15.string() }),
+  /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
+  z15.object({ type: z15.literal("session.interrupt"), id: z15.string(), restoreQueue: z15.boolean().optional() }),
   /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
-  z14.object({ type: z14.literal("session.dismiss"), id: z14.string() }),
+  z15.object({ type: z15.literal("session.dismiss"), id: z15.string() }),
   /** Puts a session in the archive: it leaves the live list but is kept. */
-  z14.object({ type: z14.literal("session.archive"), id: z14.string() }),
+  z15.object({ type: z15.literal("session.archive"), id: z15.string() }),
   /** Takes an archived session back out of the archive, as it was. */
-  z14.object({ type: z14.literal("session.restore"), id: z14.string() }),
+  z15.object({ type: z15.literal("session.restore"), id: z15.string() }),
   /** Starts the agent again on an archived session's conversation. */
-  z14.object({ type: z14.literal("session.resume"), id: z14.string() }),
+  z15.object({ type: z15.literal("session.resume"), id: z15.string() }),
+  /** Changes a live session's model and effort (#58, lot 2), `null` for the agent's own default: the daemon restarts the
+   *  agent on the same conversation with them, at once when the session is free, else at its next free moment. */
+  z15.object({ type: z15.literal("session.model"), id: z15.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** Deletes a session for good, archived or not. */
-  z14.object({ type: z14.literal("session.delete"), id: z14.string() }),
+  z15.object({ type: z15.literal("session.delete"), id: z15.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. */
-  z14.object({ type: z14.literal("session.rename"), id: z14.string(), topic: z14.string().max(500) }),
-  z14.object({ type: z14.literal("session.thread"), id: z14.string() }),
-  z14.object({ type: z14.literal("session.register"), session: SessionSchema }),
+  z15.object({ type: z15.literal("session.rename"), id: z15.string(), topic: z15.string().max(500) }),
+  z15.object({ type: z15.literal("session.thread"), id: z15.string() }),
+  z15.object({ type: z15.literal("session.register"), session: SessionSchema }),
   /** `agent` and `cwd` describe the session when the daemon does not know it yet (a hook from an agent started without ledge). */
-  z14.object({ type: z14.literal("session.event"), id: z14.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z14.string().optional() }),
-  z14.object({ type: z14.literal("session.unregister"), id: z14.string(), exitCode: z14.number().int().nullable() }),
-  z14.object({ type: z14.literal("snapshot.request") }),
-  z14.object({ type: z14.literal("chat.ask"), qid: z14.string().min(1), text: z14.string().min(1), tool: ToolSchema.optional() }),
-  z14.object({ type: z14.literal("chat.cancel"), qid: z14.string().min(1) }),
+  z15.object({ type: z15.literal("session.event"), id: z15.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z15.string().optional() }),
+  z15.object({ type: z15.literal("session.unregister"), id: z15.string(), exitCode: z15.number().int().nullable() }),
+  z15.object({ type: z15.literal("snapshot.request") }),
+  z15.object({ type: z15.literal("chat.ask"), qid: z15.string().min(1), text: z15.string().min(1), tool: ToolSchema.optional() }),
+  z15.object({ type: z15.literal("chat.cancel"), qid: z15.string().min(1) }),
   /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
-  z14.object({ type: z14.literal("chat.reset") }),
+  z15.object({ type: z15.literal("chat.reset") }),
   /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
-  z14.object({ type: z14.literal("update.daemon"), version: z14.string().regex(SEMVER) }),
+  z15.object({ type: z15.literal("update.daemon"), version: z15.string().regex(SEMVER) }),
   /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
-  z14.object({ type: z14.literal("machines.set"), machines: MachinesSchema }),
+  z15.object({ type: z15.literal("machines.set"), machines: MachinesSchema }),
   /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
-  z14.object({ type: z14.literal("projects.set"), projects: ProjectsSchema }),
+  z15.object({ type: z15.literal("projects.set"), projects: ProjectsSchema }),
   /** Replaces the island's settings as a whole; refused unless valid. */
-  z14.object({ type: z14.literal("island.set"), prefs: IslandPrefsSchema }),
+  z15.object({ type: z15.literal("island.set"), prefs: IslandPrefsSchema }),
+  /** Mobile access (lot 3), local fronts only. A changed `relayUrl` drops the relay session. */
+  z15.object({ type: z15.literal("mobile.set"), enabled: z15.boolean(), relayUrl: RelayUrlSchema }),
+  z15.object({ type: z15.literal("mobile.signin") }),
+  z15.object({ type: z15.literal("mobile.signin.cancel") }),
+  z15.object({ type: z15.literal("mobile.signout") }),
+  /** While the link is offline: try again now. */
+  z15.object({ type: z15.literal("mobile.retry") }),
+  z15.object({ type: z15.literal("mobile.pairing.approve"), id: z15.string().min(1).max(100) }),
+  z15.object({ type: z15.literal("mobile.pairing.deny"), id: z15.string().min(1).max(100) }),
+  /** `id`: the device's fingerprint. */
+  z15.object({ type: z15.literal("mobile.device.revoke"), id: z15.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. */
-  z14.object({ type: z14.literal("session.message"), rid: z14.string().min(1), from: z14.string().min(1), to: z14.string().min(1), text: z14.string().min(1).max(MESSAGE_MAX), summary: z14.string().max(SUMMARY_MAX).optional(), intercept: z14.boolean().optional() })
+  z15.object({ type: z15.literal("session.message"), rid: z15.string().min(1), from: z15.string().min(1), to: z15.string().min(1), text: z15.string().min(1).max(MESSAGE_MAX), summary: z15.string().max(SUMMARY_MAX).optional(), intercept: z15.boolean().optional() })
 ]);
 function parseClientMessage(raw) {
   return ClientMessageSchema.parse(raw);
@@ -729,14 +848,14 @@ function pickName(taken, preferred) {
 }
 
 // ../protocol/src/proposal.ts
-import { z as z15 } from "zod";
-var ProposalBlockSchema = z15.object({ cwd: z15.string().trim().min(1), prompt: z15.string().optional() });
-var RelayBlockSchema = z15.object({ session: z15.string().trim().min(1), text: z15.string().trim().min(1) });
-var ProjectBlockSchema = z15.object({
-  name: z15.string().trim().min(1).max(80),
-  description: z15.string().max(500).optional(),
-  repos: z15.array(z15.object({ path: z15.string().min(1).max(4096), why: z15.string().trim().min(1).max(200) })).min(1).max(50),
-  addTo: z15.string().trim().max(80).optional()
+import { z as z16 } from "zod";
+var ProposalBlockSchema = z16.object({ cwd: z16.string().trim().min(1), prompt: z16.string().optional() });
+var RelayBlockSchema = z16.object({ session: z16.string().trim().min(1), text: z16.string().trim().min(1) });
+var ProjectBlockSchema = z16.object({
+  name: z16.string().trim().min(1).max(80),
+  description: z16.string().max(500).optional(),
+  repos: z16.array(z16.object({ path: z16.string().min(1).max(4096), why: z16.string().trim().min(1).max(200) })).min(1).max(50),
+  addTo: z16.string().trim().max(80).optional()
 });
 var BLOCK = /```ledge-(session|relay|project)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
 function extractProposal(answer) {
@@ -784,6 +903,166 @@ function sessionTitle(s) {
   return `${s.name} \xB7 ${s.topic || s.project}`;
 }
 
+// ../protocol/src/relay.ts
+import { z as z17 } from "zod";
+var SEALED_MAX = 1048576;
+var RelayPeerSchema = z17.union([z17.literal("pc"), z17.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
+var RelayClientMessageSchema = z17.object({
+  type: z17.literal("send"),
+  to: RelayPeerSchema,
+  body: z17.string().max(SEALED_MAX)
+});
+var RelayServerMessageSchema = z17.discriminatedUnion("type", [
+  z17.object({ type: z17.literal("welcome"), accountId: z17.string(), self: RelayPeerSchema, online: z17.array(RelayPeerSchema) }),
+  z17.object({ type: z17.literal("deliver"), from: RelayPeerSchema, body: z17.string() }),
+  z17.object({ type: z17.literal("presence"), peer: RelayPeerSchema, online: z17.boolean() }),
+  /**
+   * A frame was refused; `to` names the target when it is known.
+   * Contract: an error concerning a sealed body (`offline`, `too_large`, or a socket closed with 4008
+   * `rate_limited`) means that body was not delivered, so the sequence on that channel is lost: the
+   * sender must re-handshake with that peer before sending to it again.
+   */
+  z17.object({
+    type: z17.literal("error"),
+    code: z17.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
+    to: RelayPeerSchema.optional()
+  })
+]);
+var PAIR_LABEL_MAX = 40;
+var KeyB64 = z17.string().regex(/^[A-Za-z0-9_-]{87}$/);
+var Nonce = z17.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var Fingerprint = z17.string().regex(/^[A-Za-z0-9_-]{22}$/);
+var SealedFrameSchema = z17.discriminatedUnion("k", [
+  /** `e` is the ephemeral key, `f` the fingerprint of the sender's static key. */
+  z17.object({ k: z17.literal("hello"), e: KeyB64, f: Fingerprint }),
+  z17.object({ k: z17.literal("msg"), s: z17.string() }),
+  z17.object({ k: z17.literal("pair_commit"), c: Nonce, label: z17.string().trim().min(1).max(PAIR_LABEL_MAX) }),
+  z17.object({ k: z17.literal("pair_offer"), pc: KeyB64, n: Nonce }),
+  z17.object({ k: z17.literal("pair_reveal"), d: KeyB64, n: Nonce }),
+  z17.object({ k: z17.literal("pair_ok") }),
+  z17.object({ k: z17.literal("pair_no") }),
+  z17.object({ k: z17.literal("denied") }),
+  z17.object({ k: z17.literal("rekey") })
+]);
+
+// ../protocol/src/relayAuth.ts
+import { z as z18 } from "zod";
+var RELAY_CLOSE_SIGNED_OUT = 4001;
+var DeviceStartResponseSchema = z18.object({
+  deviceCode: z18.string().min(1),
+  userCode: z18.string().min(1),
+  verificationUri: z18.string().min(1),
+  expiresIn: z18.number().int().positive(),
+  interval: z18.number().int().positive()
+});
+var DevicePollResponseSchema = z18.discriminatedUnion("status", [
+  z18.object({ status: z18.literal("pending") }),
+  z18.object({ status: z18.literal("slow_down"), interval: z18.number().int().positive() }),
+  /** `token` is the relay session token, shown this once only. */
+  z18.object({ status: z18.literal("ok"), token: z18.string().min(1), accountId: z18.string().min(1), login: z18.string().min(1) }),
+  z18.object({ status: z18.literal("expired") }),
+  z18.object({ status: z18.literal("denied") }),
+  z18.object({ status: z18.literal("not_allowed") })
+]);
+var DeviceRevokeResponseSchema = z18.object({ revoked: z18.number().int().min(0) });
+var MeResponseSchema = z18.object({
+  accountId: z18.string().min(1),
+  login: z18.string().min(1),
+  peer: RelayPeerSchema,
+  kind: z18.enum(["pc", "device"])
+});
+
+// ../protocol/src/phone.ts
+import { z as z19 } from "zod";
+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 = z19.enum(["low", "high"]);
+var RiskReasonSchema = z19.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 = z19.string().uuid();
+var OperationStatusSchema = z19.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z19.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict"]);
+var CapabilitiesSchema = z19.object({
+  /** A question can be answered in free text. */
+  freeTextAnswer: z19.boolean()
+});
+var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
+var CapabilitiesByToolSchema = z19.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z19.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z19.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
+}).extend({ pending: PhonePendingSchema.optional(), unread: z19.boolean() });
+var sessionId = z19.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z19.string().min(1).max(64) });
+var PhoneClientMessageSchema = z19.discriminatedUnion("type", [
+  z19.object({ type: z19.literal("snapshot.request") }),
+  z19.object({ type: z19.literal("session.thread"), id: sessionId }),
+  /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
+  z19.object({ type: z19.literal("session.pending"), id: sessionId }),
+  /** The session whose terminal the phone shows; null when it shows none. */
+  z19.object({ type: z19.literal("session.watch"), id: sessionId.nullable() }),
+  z19.object({ type: z19.literal("session.read"), id: sessionId, at: z19.string().datetime() }),
+  z19.object({
+    type: z19.literal("session.decide"),
+    op: OperationIdSchema,
+    id: sessionId,
+    decision: DecisionSchema,
+    note: z19.string().trim().min(1).max(NOTE_MAX).optional(),
+    /** The request the phone showed: refused unless it is still the pending one. */
+    expect: PhoneExpectSchema
+  }),
+  z19.object({
+    type: z19.literal("session.reply"),
+    op: OperationIdSchema,
+    id: sessionId,
+    text: z19.string().min(1).max(MESSAGE_MAX),
+    /** The request the reply answers, or null when the phone showed none: refused if the session's request is no longer that one. */
+    expect: PhoneExpectSchema.nullable()
+  }),
+  z19.object({ type: z19.literal("session.interrupt"), op: OperationIdSchema, id: sessionId })
+]);
+var PhoneServerMessageSchema = z19.discriminatedUnion("type", [
+  z19.object({ type: z19.literal("snapshot"), protocol: z19.literal(PHONE_PROTOCOL), sessions: z19.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z19.object({ version: z19.string(), name: z19.string().max(40) }) }),
+  z19.object({ type: z19.literal("session.updated"), session: PhoneSessionSchema }),
+  z19.object({ type: z19.literal("session.removed"), id: z19.string() }),
+  /** `pending.cut` is set when even this body was shortened. */
+  z19.object({ type: z19.literal("session.pending"), id: z19.string(), pending: PhonePendingSchema }),
+  z19.object({ type: z19.literal("session.preview"), id: z19.string(), lines: z19.array(z19.string()) }),
+  /** `cut`: the ids of the items shortened; `more`: older items were left out. */
+  z19.object({ type: z19.literal("session.thread"), id: z19.string(), items: z19.array(ThreadItemSchema), cut: z19.array(z19.string()), more: z19.boolean() }),
+  z19.object({ type: z19.literal("session.thread.item"), id: z19.string(), item: ThreadItemSchema, cut: z19.literal(true).optional() }),
+  z19.object({ type: z19.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
+  /** Never carries free text. */
+  z19.object({ type: z19.literal("error"), code: z19.enum(["invalid", "unknown_session", "too_large"]), request: z19.string().max(40).optional() })
+]);
+
 // src/auth.ts
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
 import { chmod, link, mkdir, readFile, unlink, writeFile } from "fs/promises";
@@ -904,7 +1183,9 @@ function readDaemonToken() {
 }
 
 export {
+  ToolSchema,
   SessionSchema,
+  backendOf,
   isArchived,
   MAX_PROPOSALS,
   proposalRows,
@@ -921,7 +1202,10 @@ export {
   ModelIdSchema,
   EffortSchema,
   RouteResultSchema,
+  DEFAULT_RELAY_URL,
+  MobileConfigSchema,
   PROTOCOL_PORT,
+  RefusalCodeSchema,
   RecentSchema,
   MESSAGE_MAX,
   SUMMARY_MAX,
@@ -932,8 +1216,25 @@ export {
   parseProposalBlock,
   parseRelayBlock,
   parseProjectBlock,
+  TOPIC_MAX,
   cleanTopic,
   sessionTitle,
+  RelayServerMessageSchema,
+  PAIR_LABEL_MAX,
+  SealedFrameSchema,
+  RELAY_CLOSE_SIGNED_OUT,
+  DeviceStartResponseSchema,
+  DevicePollResponseSchema,
+  PHONE_PROTOCOL,
+  padPlain,
+  THREAD_ITEMS_MAX,
+  THREAD_BUDGET,
+  THREAD_TEXT_MAX,
+  TOOL_TEXT_MAX,
+  PENDING_BODY_MAX,
+  SNAPSHOT_BODY_MAX,
+  UNTYPABLE,
+  PhoneClientMessageSchema,
   hostAllowed,
   requestAuthorized,
   selectDaemonProtocol,