@paradow/ledge 0.36.0 → 0.37.0

package/dist/cli/reduceWorker.js

@@ -728,8 +728,12 @@ var ProjectsSchema = z14.object({ projects: z14.array(ProjectSchema).max(100), r
   for (const problem of projectsProblems(p)) ctx.addIssue({ code: "custom", message: problem.code, path: problem.path });
 });
 
+// ../protocol/src/broadcast.ts
+var BROADCAST_SESSIONS_MAX = 32;
+var BROADCAST_LABEL_MAX = 120;
+
 // ../protocol/src/messages.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // ../protocol/src/repos.ts
 import { z as z15 } from "zod";
@@ -742,437 +746,461 @@ var ReposInspectSchema = z15.object({
 var RepoInfoSchema = z15.object({ path: z15.string(), exists: z15.boolean(), branch: z15.string().nullable() });
 var ReposInfoSchema = z15.object({ type: z15.literal("repos.info"), requestId: z15.string(), repos: z15.array(RepoInfoSchema) });
 
-// ../protocol/src/scan.ts
+// ../protocol/src/commands.ts
 import { z as z16 } from "zod";
-var ReposScanSchema = z16.object({ type: z16.literal("repos.scan"), requestId: z16.string().min(1).max(100), machineId: z16.string().optional() });
-var FoundRepoSchema = z16.object({ path: z16.string(), branch: z16.string().nullable(), remote: z16.string().optional(), manifest: z16.string().max(200).optional() });
-var ReposFoundSchema = z16.object({ type: z16.literal("repos.found"), requestId: z16.string(), repos: z16.array(FoundRepoSchema).max(500), truncated: z16.boolean(), error: z16.string().optional() });
+var SlashSourceSchema = z16.enum(["builtin", "project", "user", "plugin", "extension"]);
+var SLASH_COMMANDS_MAX = 400;
+var SLASH_DESCRIPTION_MAX = 300;
+var SlashCommandSchema = z16.object({
+  name: z16.string().min(1).max(200),
+  description: z16.string().max(SLASH_DESCRIPTION_MAX).optional(),
+  argumentHint: z16.string().max(200).optional(),
+  aliases: z16.array(z16.string().min(1).max(200)).max(10).optional(),
+  source: SlashSourceSchema,
+  blocked: z16.enum(["panel", "close"]).optional(),
+  bare: z16.literal("panel").optional()
+});
+var SessionCommandsSchema = z16.object({ type: z16.literal("session.commands"), requestId: z16.string().min(1).max(100), id: z16.string() });
+var SessionCommandsListingSchema = z16.object({
+  type: z16.literal("session.commands.listing"),
+  requestId: z16.string(),
+  id: z16.string(),
+  tool: ToolSchema.optional(),
+  commands: z16.array(SlashCommandSchema).max(SLASH_COMMANDS_MAX),
+  error: z16.string().max(200).optional()
+});
 
-// ../protocol/src/openrig.ts
+// ../protocol/src/scan.ts
 import { z as z17 } from "zod";
-var RigNameSchema = z17.string().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a rig name");
-var RigSeatNameSchema = z17.string().min(3).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a seat");
-var SeatPermissionsSchema = z17.enum(["inherit", "floor", "auto", "full_bypass"]);
-var RigSeatSchema = z17.object({
-  logicalId: z17.string(),
-  session: z17.string(),
-  runtime: z17.string(),
-  model: z17.string().nullable(),
-  sessionStatus: z17.string(),
-  lifecycleState: z17.string(),
-  activity: z17.string(),
-  stopped: z17.boolean(),
-  work: z17.number().int().min(0)
-});
-var RigSchema = z17.object({
-  id: z17.string(),
-  name: z17.string(),
-  status: z17.string(),
-  lifecycleState: z17.string(),
-  seats: z17.number().int().min(0),
-  running: z17.number().int().min(0),
-  attention: z17.number().int().min(0),
-  uptime: z17.string().nullable(),
-  snapshot: z17.string().nullable(),
-  nodes: z17.array(RigSeatSchema)
-});
-var RigDaemonStateSchema = z17.enum(["running", "stopped", "stale", "unknown"]);
-var RigKernelStateSchema = z17.enum(["ready", "starting", "stopped", "skipped", "absent", "unknown"]);
-var OpenRigStateSchema = z17.object({
-  installed: z17.boolean(),
-  version: z17.string().optional(),
-  daemon: z17.object({ state: RigDaemonStateSchema, pid: z17.number().int().optional(), port: z17.number().int().optional(), message: z17.string().optional() }),
-  kernel: z17.object({ state: RigKernelStateSchema }),
-  rigs: z17.array(RigSchema),
+var ReposScanSchema = z17.object({ type: z17.literal("repos.scan"), requestId: z17.string().min(1).max(100), machineId: z17.string().optional() });
+var FoundRepoSchema = z17.object({ path: z17.string(), branch: z17.string().nullable(), remote: z17.string().optional(), manifest: z17.string().max(200).optional() });
+var ReposFoundSchema = z17.object({ type: z17.literal("repos.found"), requestId: z17.string(), repos: z17.array(FoundRepoSchema).max(500), truncated: z17.boolean(), error: z17.string().optional() });
+
+// ../protocol/src/openrig.ts
+import { z as z18 } from "zod";
+var RigNameSchema = z18.string().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a rig name");
+var RigSeatNameSchema = z18.string().min(3).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9._-]*$/, "not a seat");
+var SeatPermissionsSchema = z18.enum(["inherit", "floor", "auto", "full_bypass"]);
+var RigSeatSchema = z18.object({
+  logicalId: z18.string(),
+  session: z18.string(),
+  runtime: z18.string(),
+  model: z18.string().nullable(),
+  sessionStatus: z18.string(),
+  lifecycleState: z18.string(),
+  activity: z18.string(),
+  stopped: z18.boolean(),
+  work: z18.number().int().min(0)
+});
+var RigSchema = z18.object({
+  id: z18.string(),
+  name: z18.string(),
+  status: z18.string(),
+  lifecycleState: z18.string(),
+  seats: z18.number().int().min(0),
+  running: z18.number().int().min(0),
+  attention: z18.number().int().min(0),
+  uptime: z18.string().nullable(),
+  snapshot: z18.string().nullable(),
+  nodes: z18.array(RigSeatSchema)
+});
+var RigDaemonStateSchema = z18.enum(["running", "stopped", "stale", "unknown"]);
+var RigKernelStateSchema = z18.enum(["ready", "starting", "stopped", "skipped", "absent", "unknown"]);
+var OpenRigStateSchema = z18.object({
+  installed: z18.boolean(),
+  version: z18.string().optional(),
+  daemon: z18.object({ state: RigDaemonStateSchema, pid: z18.number().int().optional(), port: z18.number().int().optional(), message: z18.string().optional() }),
+  kernel: z18.object({ state: RigKernelStateSchema }),
+  rigs: z18.array(RigSchema),
   /** When it was read (ISO). */
-  at: z17.string()
+  at: z18.string()
 });
-var OpenRigActionSchema = z17.discriminatedUnion("kind", [
+var OpenRigActionSchema = z18.discriminatedUnion("kind", [
   /** `restore` `last`: `rig start --last` (the rigs that were running come back); `none`: `rig daemon start`. */
-  z17.object({ kind: z17.literal("daemon.start"), restore: z17.enum(["last", "none"]).optional(), noKernel: z17.boolean().optional() }),
-  z17.object({ kind: z17.literal("daemon.stop") }),
-  z17.object({ kind: z17.literal("daemon.restart"), restore: z17.enum(["last", "none"]).optional() }),
-  z17.object({ kind: z17.literal("kernel.start") }),
-  z17.object({ kind: z17.literal("kernel.stop") }),
-  z17.object({ kind: z17.literal("kernel.restart") }),
-  z17.object({ kind: z17.literal("rig.start"), rig: RigNameSchema }),
-  z17.object({ kind: z17.literal("rig.stop"), rig: RigNameSchema, snapshot: z17.boolean().optional(), force: z17.boolean().optional(), delete: z17.boolean().optional() }),
-  z17.object({ kind: z17.literal("rig.restart"), rig: RigNameSchema }),
+  z18.object({ kind: z18.literal("daemon.start"), restore: z18.enum(["last", "none"]).optional(), noKernel: z18.boolean().optional() }),
+  z18.object({ kind: z18.literal("daemon.stop") }),
+  z18.object({ kind: z18.literal("daemon.restart"), restore: z18.enum(["last", "none"]).optional() }),
+  z18.object({ kind: z18.literal("kernel.start") }),
+  z18.object({ kind: z18.literal("kernel.stop") }),
+  z18.object({ kind: z18.literal("kernel.restart") }),
+  z18.object({ kind: z18.literal("rig.start"), rig: RigNameSchema }),
+  z18.object({ kind: z18.literal("rig.stop"), rig: RigNameSchema, snapshot: z18.boolean().optional(), force: z18.boolean().optional(), delete: z18.boolean().optional() }),
+  z18.object({ kind: z18.literal("rig.restart"), rig: RigNameSchema }),
   /** A seat's settings (docs/mockups/ledge-openrig-groups.html, view 2). `runtime`: moves it now to the other harness (a successor
    *  takes its context, `rig seat set-runtime`), `model` and `effort` going with it; without it, `model`, `effort` and `permissions`
    *  apply at its next resume. `dryRun`: the move's plan only. */
-  z17.object({
-    kind: z17.literal("seat.set"),
+  z18.object({
+    kind: z18.literal("seat.set"),
     seat: RigSeatNameSchema,
-    runtime: z17.enum(["claude-code", "codex"]).optional(),
+    runtime: z18.enum(["claude-code", "codex"]).optional(),
     model: ModelIdSchema.optional(),
     effort: EffortSchema.optional(),
     permissions: SeatPermissionsSchema.optional(),
-    dryRun: z17.boolean().optional()
+    dryRun: z18.boolean().optional()
   })
 ]);
-var OpenRigStatusSchema = z17.object({ type: z17.literal("openrig.status"), requestId: z17.string().min(1).max(100), machineId: z17.string().optional() });
-var OpenRigActSchema = z17.object({ type: z17.literal("openrig.act"), requestId: z17.string().min(1).max(100), action: OpenRigActionSchema, machineId: z17.string().optional() });
-var OpenRigUnreachableSchema = z17.enum(["offline", "outdated"]);
-var OpenRigStateMessageSchema = z17.object({
-  type: z17.literal("openrig.state"),
-  requestId: z17.string().optional(),
-  machineId: z17.string().optional(),
+var OpenRigStatusSchema = z18.object({ type: z18.literal("openrig.status"), requestId: z18.string().min(1).max(100), machineId: z18.string().optional() });
+var OpenRigActSchema = z18.object({ type: z18.literal("openrig.act"), requestId: z18.string().min(1).max(100), action: OpenRigActionSchema, machineId: z18.string().optional() });
+var OpenRigUnreachableSchema = z18.enum(["offline", "outdated"]);
+var OpenRigStateMessageSchema = z18.object({
+  type: z18.literal("openrig.state"),
+  requestId: z18.string().optional(),
+  machineId: z18.string().optional(),
   state: OpenRigStateSchema.optional(),
   error: OpenRigUnreachableSchema.optional()
 });
-var OpenRigDoneSchema = z17.object({
-  type: z17.literal("openrig.done"),
-  requestId: z17.string(),
-  machineId: z17.string().optional(),
-  ok: z17.boolean(),
-  commands: z17.array(z17.string()),
-  output: z17.string().optional(),
-  error: z17.string().optional()
-});
-var RigSpecMemberSchema = z17.object({
-  id: z17.string(),
-  runtime: z17.string(),
-  model: z17.string().optional(),
-  agent: z17.string(),
+var OpenRigDoneSchema = z18.object({
+  type: z18.literal("openrig.done"),
+  requestId: z18.string(),
+  machineId: z18.string().optional(),
+  ok: z18.boolean(),
+  commands: z18.array(z18.string()),
+  output: z18.string().optional(),
+  error: z18.string().optional()
+});
+var RigSpecMemberSchema = z18.object({
+  id: z18.string(),
+  runtime: z18.string(),
+  model: z18.string().optional(),
+  agent: z18.string(),
   /** Its `permission_policy`, as written. */
-  policy: z17.string().optional()
-});
-var RigSpecPodSchema = z17.object({ id: z17.string(), label: z17.string().optional(), members: z17.array(RigSpecMemberSchema) });
-var RigSpecSchema = z17.object({
-  name: z17.string(),
-  source: z17.string(),
-  summary: z17.string().optional(),
-  path: z17.string(),
+  policy: z18.string().optional()
+});
+var RigSpecPodSchema = z18.object({ id: z18.string(), label: z18.string().optional(), members: z18.array(RigSpecMemberSchema) });
+var RigSpecSchema = z18.object({
+  name: z18.string(),
+  source: z18.string(),
+  summary: z18.string().optional(),
+  path: z18.string(),
   /** The rig's `permission_policy`, as written (`builtin:auto`, a file…). */
-  policy: z17.string().optional(),
-  pods: z17.array(RigSpecPodSchema),
-  edges: z17.number().int().min(0)
-});
-var OpenRigSpecsSchema = z17.object({ type: z17.literal("openrig.specs"), requestId: z17.string().min(1).max(100), machineId: z17.string().optional() });
-var OpenRigSpecListSchema = z17.object({
-  type: z17.literal("openrig.specList"),
-  requestId: z17.string(),
-  machineId: z17.string().optional(),
-  specs: z17.array(RigSpecSchema),
-  error: z17.string().optional()
-});
-var RigRoleSchema = z17.string().min(3).max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*\.[A-Za-z0-9][A-Za-z0-9_-]*$/, "not a role");
-var RuntimeSchema = z17.enum(["claude-code", "codex"]);
-var RigPolicySchema = z17.enum(["auto", "standard", "open", "yolo", "locked"]);
+  policy: z18.string().optional(),
+  pods: z18.array(RigSpecPodSchema),
+  edges: z18.number().int().min(0)
+});
+var OpenRigSpecsSchema = z18.object({ type: z18.literal("openrig.specs"), requestId: z18.string().min(1).max(100), machineId: z18.string().optional() });
+var OpenRigSpecListSchema = z18.object({
+  type: z18.literal("openrig.specList"),
+  requestId: z18.string(),
+  machineId: z18.string().optional(),
+  specs: z18.array(RigSpecSchema),
+  error: z18.string().optional()
+});
+var RigRoleSchema = z18.string().min(3).max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*\.[A-Za-z0-9][A-Za-z0-9_-]*$/, "not a role");
+var RuntimeSchema = z18.enum(["claude-code", "codex"]);
+var RigPolicySchema = z18.enum(["auto", "standard", "open", "yolo", "locked"]);
 var RIG_POLICIES = RigPolicySchema.options;
-var RigLaunchSchema = z17.object({
+var RigLaunchSchema = z18.object({
   spec: RigNameSchema,
-  cwd: z17.string().min(1).max(4096),
+  cwd: z18.string().min(1).max(4096),
   name: RigNameSchema,
-  seats: z17.record(RigRoleSchema, z17.number().int().min(0).max(9)).optional(),
-  runtimes: z17.record(RigRoleSchema, RuntimeSchema).optional(),
-  models: z17.record(RigRoleSchema, z17.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/)).optional(),
-  delegation: z17.enum(["pairs", "all"]).optional(),
-  save: z17.boolean().optional(),
-  plan: z17.boolean().optional(),
+  seats: z18.record(RigRoleSchema, z18.number().int().min(0).max(9)).optional(),
+  runtimes: z18.record(RigRoleSchema, RuntimeSchema).optional(),
+  models: z18.record(RigRoleSchema, z18.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]=,+-]*$/)).optional(),
+  delegation: z18.enum(["pairs", "all"]).optional(),
+  save: z18.boolean().optional(),
+  plan: z18.boolean().optional(),
   /** The rig's permission policy, in place of the spec's; `policies`: a role's, over the rig's. */
   policy: RigPolicySchema.optional(),
-  policies: z17.record(RigRoleSchema, RigPolicySchema).optional(),
+  policies: z18.record(RigRoleSchema, RigPolicySchema).optional(),
   /** Accept the harnesses' first-launch warnings (`rig up --non-interruptive`), so a bypassing seat does not stop on Claude's dialog. */
-  nonInterruptive: z17.boolean().optional()
-});
-var OpenRigLaunchSchema = z17.object({ type: z17.literal("openrig.launch"), requestId: z17.string().min(1).max(100), launch: RigLaunchSchema, machineId: z17.string().optional() });
-var OpenRigLaunchedSchema = z17.object({
-  type: z17.literal("openrig.launched"),
-  requestId: z17.string(),
-  machineId: z17.string().optional(),
-  ok: z17.boolean(),
-  plan: z17.boolean(),
-  commands: z17.array(z17.string()),
-  yaml: z17.string().optional(),
-  seats: z17.number().int().optional(),
-  output: z17.string().optional(),
-  error: z17.string().optional(),
+  nonInterruptive: z18.boolean().optional()
+});
+var OpenRigLaunchSchema = z18.object({ type: z18.literal("openrig.launch"), requestId: z18.string().min(1).max(100), launch: RigLaunchSchema, machineId: z18.string().optional() });
+var OpenRigLaunchedSchema = z18.object({
+  type: z18.literal("openrig.launched"),
+  requestId: z18.string(),
+  machineId: z18.string().optional(),
+  ok: z18.boolean(),
+  plan: z18.boolean(),
+  commands: z18.array(z18.string()),
+  yaml: z18.string().optional(),
+  seats: z18.number().int().optional(),
+  output: z18.string().optional(),
+  error: z18.string().optional(),
   /** What `rig up --plan` concluded: its status (`planned`…), its errors and its warnings (one per seat without a permission policy…). */
-  check: z17.object({ status: z17.string(), errors: z17.array(z17.string()), warnings: z17.array(z17.string()) }).optional()
+  check: z18.object({ status: z18.string(), errors: z18.array(z18.string()), warnings: z18.array(z18.string()) }).optional()
 });
-var OpenRigSeatsSchema = z17.object({
-  type: z17.literal("openrig.seats"),
-  requestId: z17.string().min(1).max(100),
-  machineId: z17.string().optional(),
+var OpenRigSeatsSchema = z18.object({
+  type: z18.literal("openrig.seats"),
+  requestId: z18.string().min(1).max(100),
+  machineId: z18.string().optional(),
   rig: RigNameSchema,
-  seats: z17.record(RigRoleSchema, z17.number().int().min(0).max(9)),
+  seats: z18.record(RigRoleSchema, z18.number().int().min(0).max(9)),
   /** How the added seats are linked, where OpenRig can add links to a running rig (0.7+): like a launch's. */
-  delegation: z17.enum(["pairs", "all"]).optional()
-});
-var OpenRigReseatedSchema = z17.object({
-  type: z17.literal("openrig.reseated"),
-  requestId: z17.string(),
-  machineId: z17.string().optional(),
-  ok: z17.boolean(),
-  commands: z17.array(z17.string()),
-  added: z17.array(z17.string()),
-  removed: z17.array(z17.string()),
-  output: z17.string().optional(),
-  error: z17.string().optional(),
+  delegation: z18.enum(["pairs", "all"]).optional()
+});
+var OpenRigReseatedSchema = z18.object({
+  type: z18.literal("openrig.reseated"),
+  requestId: z18.string(),
+  machineId: z18.string().optional(),
+  ok: z18.boolean(),
+  commands: z18.array(z18.string()),
+  added: z18.array(z18.string()),
+  removed: z18.array(z18.string()),
+  output: z18.string().optional(),
+  error: z18.string().optional(),
   /** The links ensured between the seats; `linksUnsupported`: this OpenRig cannot add links to a running rig (before 0.7). */
-  links: z17.number().int().optional(),
-  linksUnsupported: z17.boolean().optional()
+  links: z18.number().int().optional(),
+  linksUnsupported: z18.boolean().optional()
 });
 
 // ../protocol/src/openrigRoles.ts
-import { z as z18 } from "zod";
-var RoleUnknownWhySchema = z18.enum(["resolved_at_launch", "not_exposed", "unreadable", "ambiguous", "not_found", "missing_from_guidance"]);
-var RoleFromSchema = z18.enum(["import", "defaults", "profile", "rig", "pod", "member", "launch", "openrig", "plugin", "seat"]);
-var OriginSchema = z18.discriminatedUnion("kind", [
-  z18.object({ kind: z18.literal("here"), key: z18.string().optional() }),
-  z18.object({ kind: z18.literal("inherited"), from: RoleFromSchema, ref: z18.string().optional(), key: z18.string().optional(), path: z18.string().optional() }),
-  z18.object({ kind: z18.literal("absent") }),
-  z18.object({ kind: z18.literal("unknown"), why: RoleUnknownWhySchema, detail: z18.string().optional() })
+import { z as z19 } from "zod";
+var RoleUnknownWhySchema = z19.enum(["resolved_at_launch", "not_exposed", "unreadable", "ambiguous", "not_found", "missing_from_guidance"]);
+var RoleFromSchema = z19.enum(["import", "defaults", "profile", "rig", "pod", "member", "launch", "openrig", "plugin", "seat"]);
+var OriginSchema = z19.discriminatedUnion("kind", [
+  z19.object({ kind: z19.literal("here"), key: z19.string().optional() }),
+  z19.object({ kind: z19.literal("inherited"), from: RoleFromSchema, ref: z19.string().optional(), key: z19.string().optional(), path: z19.string().optional() }),
+  z19.object({ kind: z19.literal("absent") }),
+  z19.object({ kind: z19.literal("unknown"), why: RoleUnknownWhySchema, detail: z19.string().optional() })
 ]);
-var SourcedStringSchema = z18.object({ value: z18.string().nullable(), origin: OriginSchema });
-var RoleResourceCategorySchema = z18.enum(["skill", "guidance", "plugin", "subagent", "runtime_resource"]);
-var RoleResourceSchema = z18.object({
+var SourcedStringSchema = z19.object({ value: z19.string().nullable(), origin: OriginSchema });
+var RoleResourceCategorySchema = z19.enum(["skill", "guidance", "plugin", "subagent", "runtime_resource"]);
+var RoleResourceSchema = z19.object({
   category: RoleResourceCategorySchema,
-  id: z18.string(),
-  path: z18.string().optional(),
-  absolutePath: z18.string().optional(),
-  runtime: z18.string().optional(),
-  type: z18.string().optional(),
-  target: z18.string().optional(),
-  plugin: z18.object({ version: z18.string().optional(), skills: z18.array(z18.string()), hooks: z18.number().int().min(0) }).optional(),
+  id: z19.string(),
+  path: z19.string().optional(),
+  absolutePath: z19.string().optional(),
+  runtime: z19.string().optional(),
+  type: z19.string().optional(),
+  target: z19.string().optional(),
+  plugin: z19.object({ version: z19.string().optional(), skills: z19.array(z19.string()), hooks: z19.number().int().min(0) }).optional(),
   origin: OriginSchema
 });
-var RoleUsesListSchema = z18.object({ declared: z18.boolean(), key: z18.string(), items: z18.array(RoleResourceSchema) });
-var StartupLayerSchema = z18.enum(["agent", "profile", "culture", "rig", "pod", "member", "openrig", "seat", "unknown"]);
-var StartupEntrySchema = z18.object({
-  kind: z18.enum(["file", "action"]),
-  path: z18.string().optional(),
-  absolutePath: z18.string().optional(),
-  size: z18.number().int().min(0).optional(),
-  value: z18.string().optional(),
-  builtin: z18.string().optional(),
+var RoleUsesListSchema = z19.object({ declared: z19.boolean(), key: z19.string(), items: z19.array(RoleResourceSchema) });
+var StartupLayerSchema = z19.enum(["agent", "profile", "culture", "rig", "pod", "member", "openrig", "seat", "unknown"]);
+var StartupEntrySchema = z19.object({
+  kind: z19.enum(["file", "action"]),
+  path: z19.string().optional(),
+  absolutePath: z19.string().optional(),
+  size: z19.number().int().min(0).optional(),
+  value: z19.string().optional(),
+  builtin: z19.string().optional(),
   layer: StartupLayerSchema,
-  layerInferred: z18.boolean(),
-  delivery: z18.string(),
-  into: z18.string().optional(),
-  delivered: z18.boolean().optional(),
-  required: z18.boolean().optional(),
-  orientation: z18.string().optional(),
-  appliesOn: z18.array(z18.string()),
+  layerInferred: z19.boolean(),
+  delivery: z19.string(),
+  into: z19.string().optional(),
+  delivered: z19.boolean().optional(),
+  required: z19.boolean().optional(),
+  orientation: z19.string().optional(),
+  appliesOn: z19.array(z19.string()),
   origin: OriginSchema
 });
-var RoleFileErrorSchema = z18.object({ kind: z18.enum(["missing", "invalid"]), message: z18.string(), line: z18.number().int().optional(), col: z18.number().int().optional() });
-var RoleSummarySchema = z18.object({
-  id: z18.string(),
-  name: z18.string(),
-  version: z18.string().optional(),
-  description: z18.string().optional(),
-  source: z18.enum(["builtin", "user"]),
-  path: z18.string(),
-  runtime: z18.string().optional(),
-  importOnly: z18.boolean(),
-  seats: z18.number().int().min(0),
-  running: z18.number().int().min(0),
-  skills: z18.array(z18.string()),
-  startupFiles: z18.array(z18.string()),
+var RoleFileErrorSchema = z19.object({ kind: z19.enum(["missing", "invalid"]), message: z19.string(), line: z19.number().int().optional(), col: z19.number().int().optional() });
+var RoleSummarySchema = z19.object({
+  id: z19.string(),
+  name: z19.string(),
+  version: z19.string().optional(),
+  description: z19.string().optional(),
+  source: z19.enum(["builtin", "user"]),
+  path: z19.string(),
+  runtime: z19.string().optional(),
+  importOnly: z19.boolean(),
+  seats: z19.number().int().min(0),
+  running: z19.number().int().min(0),
+  skills: z19.array(z19.string()),
+  startupFiles: z19.array(z19.string()),
   /** The seats that run it, so a seat of the Rigs page opens its role « seen from » it (`openrig.role` with `id`, then the seat by `rig` + `logicalId`). */
-  seatRefs: z18.array(z18.object({ rig: z18.string(), logicalId: z18.string(), session: z18.string().optional() })),
-  error: z18.enum(["missing", "invalid"]).optional()
-});
-var RoleImportSchema = z18.object({
-  ref: z18.string(),
-  key: z18.string(),
-  name: z18.string().optional(),
-  path: z18.string().optional(),
-  version: z18.string().optional(),
-  resolved: z18.boolean(),
-  error: z18.string().optional()
-});
-var RoleProfileSchema = z18.object({
-  name: z18.string(),
-  description: z18.string().optional(),
+  seatRefs: z19.array(z19.object({ rig: z19.string(), logicalId: z19.string(), session: z19.string().optional() })),
+  error: z19.enum(["missing", "invalid"]).optional()
+});
+var RoleImportSchema = z19.object({
+  ref: z19.string(),
+  key: z19.string(),
+  name: z19.string().optional(),
+  path: z19.string().optional(),
+  version: z19.string().optional(),
+  resolved: z19.boolean(),
+  error: z19.string().optional()
+});
+var RoleProfileSchema = z19.object({
+  name: z19.string(),
+  description: z19.string().optional(),
   runtime: SourcedStringSchema,
   model: SourcedStringSchema,
   effort: SourcedStringSchema,
-  uses: z18.object({ skills: RoleUsesListSchema, guidance: RoleUsesListSchema, subagents: RoleUsesListSchema, plugins: RoleUsesListSchema, runtimeResources: RoleUsesListSchema }),
+  uses: z19.object({ skills: RoleUsesListSchema, guidance: RoleUsesListSchema, subagents: RoleUsesListSchema, plugins: RoleUsesListSchema, runtimeResources: RoleUsesListSchema }),
   /** The role's share of the startup: agent then profile files and actions, in that order. */
-  startup: z18.array(StartupEntrySchema)
-});
-var RoleSeatSchema = z18.object({
-  rig: z18.string(),
-  rigId: z18.string(),
-  rigSpecPath: z18.string().optional(),
-  composed: z18.boolean(),
-  logicalId: z18.string(),
-  session: z18.string().optional(),
-  label: z18.string().optional(),
-  profile: z18.string(),
-  running: z18.boolean(),
-  activity: z18.string(),
+  startup: z19.array(StartupEntrySchema)
+});
+var RoleSeatSchema = z19.object({
+  rig: z19.string(),
+  rigId: z19.string(),
+  rigSpecPath: z19.string().optional(),
+  composed: z19.boolean(),
+  logicalId: z19.string(),
+  session: z19.string().optional(),
+  label: z19.string().optional(),
+  profile: z19.string(),
+  running: z19.boolean(),
+  activity: z19.string(),
   runtime: SourcedStringSchema,
   model: SourcedStringSchema,
   effort: SourcedStringSchema,
   cwd: SourcedStringSchema,
   cultureFile: SourcedStringSchema,
-  member: z18.string().optional(),
-  memberStartup: z18.array(StartupEntrySchema),
+  member: z19.string().optional(),
+  memberStartup: z19.array(StartupEntrySchema),
   /** The Role tab of this seat: its role guidance (`role.md`), then the startup files of its own (member layer), in delivery
    *  order — OpenRig's when the seat was launched, else the spec's. */
-  roleDocs: z18.array(StartupEntrySchema),
-  live: z18.object({
-    resolvedSpec: z18.object({ name: z18.string().optional(), version: z18.string().optional(), hash: z18.string().optional() }),
-    resources: z18.array(RoleResourceSchema),
+  roleDocs: z19.array(StartupEntrySchema),
+  live: z19.object({
+    resolvedSpec: z19.object({ name: z19.string().optional(), version: z19.string().optional(), hash: z19.string().optional() }),
+    resources: z19.array(RoleResourceSchema),
     /** In the order OpenRig returns them. */
-    startup: z18.array(StartupEntrySchema),
+    startup: z19.array(StartupEntrySchema),
     /** `rig skill loadout --seat`: the skills projected for this seat; absent when it could not be read. */
-    skills: z18.array(z18.object({ id: z18.string(), trigger: z18.string().optional() })).optional()
+    skills: z19.array(z19.object({ id: z19.string(), trigger: z19.string().optional() })).optional()
   }).optional()
 });
-var RoleUnavailableSchema = z18.enum(["harness_prompt", "effective_settings", "delivered_content", "harness_own_files"]);
-var RoleDetailSchema = z18.object({
+var RoleUnavailableSchema = z19.enum(["harness_prompt", "effective_settings", "delivered_content", "harness_own_files"]);
+var RoleDetailSchema = z19.object({
   summary: RoleSummarySchema,
-  file: z18.object({
-    path: z18.string(),
-    relativePath: z18.string().optional(),
-    modifiedAt: z18.string().optional(),
-    copies: z18.array(z18.object({ kind: z18.literal("repo"), path: z18.string(), identical: z18.boolean(), modifiedAt: z18.string().optional() }))
+  file: z19.object({
+    path: z19.string(),
+    relativePath: z19.string().optional(),
+    modifiedAt: z19.string().optional(),
+    copies: z19.array(z19.object({ kind: z19.literal("repo"), path: z19.string(), identical: z19.boolean(), modifiedAt: z19.string().optional() }))
   }),
   error: RoleFileErrorSchema.optional(),
-  role: z18.object({ path: z18.string(), absolutePath: z18.string(), origin: OriginSchema }).nullable(),
-  defaults: z18.object({ runtime: SourcedStringSchema, model: SourcedStringSchema, effort: SourcedStringSchema }),
-  imports: z18.array(RoleImportSchema),
-  importedBy: z18.array(z18.string()),
-  profiles: z18.array(RoleProfileSchema),
+  role: z19.object({ path: z19.string(), absolutePath: z19.string(), origin: OriginSchema }).nullable(),
+  defaults: z19.object({ runtime: SourcedStringSchema, model: SourcedStringSchema, effort: SourcedStringSchema }),
+  imports: z19.array(RoleImportSchema),
+  importedBy: z19.array(z19.string()),
+  profiles: z19.array(RoleProfileSchema),
   /** What the file declares in `resources`. */
-  resources: z18.array(RoleResourceSchema),
-  seats: z18.array(RoleSeatSchema),
-  unavailable: z18.array(RoleUnavailableSchema),
-  warnings: z18.array(z18.string()),
-  openrigVersion: z18.string().optional()
-});
-var RoleErrorSchema = z18.string();
-var LibraryIdSchema = z18.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "not a library id");
-var OpenRigRolesSchema = z18.object({ type: z18.literal("openrig.roles"), requestId: z18.string().min(1).max(100), machineId: z18.string().optional() });
-var OpenRigRoleListSchema = z18.object({
-  type: z18.literal("openrig.roleList"),
-  requestId: z18.string(),
-  machineId: z18.string().optional(),
-  roles: z18.array(RoleSummarySchema),
-  openrigVersion: z18.string().optional(),
+  resources: z19.array(RoleResourceSchema),
+  seats: z19.array(RoleSeatSchema),
+  unavailable: z19.array(RoleUnavailableSchema),
+  warnings: z19.array(z19.string()),
+  openrigVersion: z19.string().optional()
+});
+var RoleErrorSchema = z19.string();
+var LibraryIdSchema = z19.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "not a library id");
+var OpenRigRolesSchema = z19.object({ type: z19.literal("openrig.roles"), requestId: z19.string().min(1).max(100), machineId: z19.string().optional() });
+var OpenRigRoleListSchema = z19.object({
+  type: z19.literal("openrig.roleList"),
+  requestId: z19.string(),
+  machineId: z19.string().optional(),
+  roles: z19.array(RoleSummarySchema),
+  openrigVersion: z19.string().optional(),
   error: RoleErrorSchema.optional()
 });
-var OpenRigRoleSchema = z18.object({ type: z18.literal("openrig.role"), requestId: z18.string().min(1).max(100), machineId: z18.string().optional(), roleId: LibraryIdSchema });
-var OpenRigRoleDetailSchema = z18.object({
-  type: z18.literal("openrig.roleDetail"),
-  requestId: z18.string(),
-  machineId: z18.string().optional(),
-  roleId: z18.string(),
+var OpenRigRoleSchema = z19.object({ type: z19.literal("openrig.role"), requestId: z19.string().min(1).max(100), machineId: z19.string().optional(), roleId: LibraryIdSchema });
+var OpenRigRoleDetailSchema = z19.object({
+  type: z19.literal("openrig.roleDetail"),
+  requestId: z19.string(),
+  machineId: z19.string().optional(),
+  roleId: z19.string(),
   role: RoleDetailSchema.optional(),
   error: RoleErrorSchema.optional()
 });
-var OpenRigRoleFileSchema = z18.object({
-  type: z18.literal("openrig.roleFile"),
-  requestId: z18.string().min(1).max(100),
-  machineId: z18.string().optional(),
+var OpenRigRoleFileSchema = z19.object({
+  type: z19.literal("openrig.roleFile"),
+  requestId: z19.string().min(1).max(100),
+  machineId: z19.string().optional(),
   roleId: LibraryIdSchema,
-  path: z18.string().min(1).max(4096)
-});
-var OpenRigRoleFileContentSchema = z18.object({
-  type: z18.literal("openrig.roleFileContent"),
-  requestId: z18.string(),
-  machineId: z18.string().optional(),
-  roleId: z18.string(),
-  path: z18.string(),
-  content: z18.string().optional(),
-  size: z18.number().int().min(0).optional(),
-  truncated: z18.boolean().optional(),
+  path: z19.string().min(1).max(4096)
+});
+var OpenRigRoleFileContentSchema = z19.object({
+  type: z19.literal("openrig.roleFileContent"),
+  requestId: z19.string(),
+  machineId: z19.string().optional(),
+  roleId: z19.string(),
+  path: z19.string(),
+  content: z19.string().optional(),
+  size: z19.number().int().min(0).optional(),
+  truncated: z19.boolean().optional(),
   error: RoleErrorSchema.optional()
 });
 var ROLE_FILE_MAX = 512 * 1024;
 
 // ../protocol/src/routing.ts
-import { z as z19 } from "zod";
-var MachineInventorySchema = z19.object({
-  id: z19.string().min(1).max(80),
-  label: z19.string().min(1).max(120),
-  online: z19.boolean(),
-  local: z19.boolean(),
-  sessions: z19.array(z19.object({ id: z19.string(), name: z19.string(), project: z19.string(), cwd: z19.string(), topic: z19.string().optional(), state: z19.string(), readOnly: z19.boolean() })).max(500),
-  folders: z19.array(z19.object({ project: z19.string(), cwd: z19.string() })).max(100)
-});
-var RoutingContextSchema = z19.object({
-  machines: z19.array(MachineInventorySchema).min(1).max(20),
-  history: z19.array(z19.object({ question: z19.string().max(2e4), answer: z19.string().max(2e4).optional(), machineId: z19.string().optional() })).max(50)
-});
-var RouteResultSchema = z19.object({
+import { z as z20 } from "zod";
+var MachineInventorySchema = z20.object({
+  id: z20.string().min(1).max(80),
+  label: z20.string().min(1).max(120),
+  online: z20.boolean(),
+  local: z20.boolean(),
+  sessions: z20.array(z20.object({ id: z20.string(), name: z20.string(), project: z20.string(), cwd: z20.string(), topic: z20.string().optional(), state: z20.string(), readOnly: z20.boolean() })).max(500),
+  folders: z20.array(z20.object({ project: z20.string(), cwd: z20.string() })).max(100)
+});
+var RoutingContextSchema = z20.object({
+  machines: z20.array(MachineInventorySchema).min(1).max(20),
+  history: z20.array(z20.object({ question: z20.string().max(2e4), answer: z20.string().max(2e4).optional(), machineId: z20.string().optional() })).max(50)
+});
+var RouteResultSchema = z20.object({
   /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z19.string().nullable(),
-  text: z19.string().min(1).max(2e4),
-  choices: z19.array(z19.string()).max(20).optional()
+  machineId: z20.string().nullable(),
+  text: z20.string().min(1).max(2e4),
+  choices: z20.array(z20.string()).max(20).optional()
 });
 
 // ../protocol/src/thread.ts
-import { z as z20 } from "zod";
-var ToolStatusSchema = z20.enum(["running", "success", "failed", "unknown"]);
-var FileChangeSchema = z20.object({ path: z20.string().min(1), from: z20.string().min(1).optional(), change: z20.enum(["add", "edit", "delete", "write"]), diff: z20.string().optional() });
-var base = { id: z20.string().min(1), at: z20.string().datetime(), turn: z20.number().int().nonnegative(), helperId: z20.string().optional() };
-var ThreadItemSchema = z20.discriminatedUnion("kind", [
-  z20.object({ kind: z20.literal("prompt"), ...base, text: z20.string(), images: z20.array(AttachmentRefSchema).optional() }),
-  z20.object({ kind: z20.literal("message"), ...base, text: z20.string() }),
+import { z as z21 } from "zod";
+var ToolStatusSchema = z21.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z21.object({ path: z21.string().min(1), from: z21.string().min(1).optional(), change: z21.enum(["add", "edit", "delete", "write"]), diff: z21.string().optional() });
+var base = { id: z21.string().min(1), at: z21.string().datetime(), turn: z21.number().int().nonnegative(), helperId: z21.string().optional() };
+var ThreadItemSchema = z21.discriminatedUnion("kind", [
+  z21.object({ kind: z21.literal("prompt"), ...base, text: z21.string(), images: z21.array(AttachmentRefSchema).optional() }),
+  z21.object({ kind: z21.literal("message"), ...base, text: z21.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. */
-  z20.object({
-    kind: z20.literal("tool"),
+  z21.object({
+    kind: z21.literal("tool"),
     ...base,
-    tool: z20.string(),
-    label: z20.string(),
-    input: z20.string().optional(),
-    output: z20.string().optional(),
-    error: z20.string().optional(),
+    tool: z21.string(),
+    label: z21.string(),
+    input: z21.string().optional(),
+    output: z21.string().optional(),
+    error: z21.string().optional(),
     status: ToolStatusSchema,
-    durationMs: z20.number().nonnegative().optional(),
-    files: z20.array(FileChangeSchema).default([]),
-    byClose: z20.literal(true).optional(),
+    durationMs: z21.number().nonnegative().optional(),
+    files: z21.array(FileChangeSchema).default([]),
+    byClose: z21.literal(true).optional(),
     /** Images the tool returned (a browser screenshot), in order; `imagesDropped`: some were not kept. */
-    images: z20.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional(),
-    imagesDropped: z20.literal(true).optional()
+    images: z21.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional(),
+    imagesDropped: z21.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. */
-  z20.object({ kind: z20.literal("permission"), ...base, tool: z20.string(), text: z20.string(), decision: z20.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z20.literal(true).optional() }),
-  z20.object({ kind: z20.literal("reply"), ...base, text: z20.string() }),
-  z20.object({ kind: z20.literal("helper"), ...base, task: z20.string(), agentType: z20.string().optional(), state: z20.enum(["working", "exited"]) }),
+  z21.object({ kind: z21.literal("permission"), ...base, tool: z21.string(), text: z21.string(), decision: z21.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z21.literal(true).optional() }),
+  z21.object({ kind: z21.literal("reply"), ...base, text: z21.string() }),
+  z21.object({ kind: z21.literal("helper"), ...base, task: z21.string(), agentType: z21.string().optional(), state: z21.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. */
-  z20.object({ kind: z20.literal("sent"), ...base, to: z20.string(), peer: z20.string().optional(), summary: z20.string().optional(), text: z20.string(), status: z20.enum(["sending", "delivered", "read", "failed"]), received: z20.string().optional(), via: z20.literal("ledge").optional() }),
+  z21.object({ kind: z21.literal("sent"), ...base, to: z21.string(), peer: z21.string().optional(), summary: z21.string().optional(), text: z21.string(), status: z21.enum(["sending", "delivered", "read", "failed"]), received: z21.string().optional(), via: z21.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. */
-  z20.object({ kind: z20.literal("received"), ...base, from: z20.string(), peer: z20.string().optional(), text: z20.string(), sent: z20.string().optional() }),
+  z21.object({ kind: z21.literal("received"), ...base, from: z21.string(), peer: z21.string().optional(), text: z21.string(), sent: z21.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`. */
-  z20.object({
-    kind: z20.literal("notice"),
+  z21.object({
+    kind: z21.literal("notice"),
     ...base,
-    notice: z20.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
+    notice: z21.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
     /** An `other` notice from Ledge: `task`, the task a `<ledge-task>` is about. An older front, which does not know it, shows it as any other notice. */
-    task: z20.string().optional(),
+    task: z21.string().optional(),
     /** A task this session handed over (`outgoing`), and how (issue #92). */
-    taskOp: z20.enum(TRANSMISSION_OPS).optional(),
-    outgoing: z20.literal(true).optional(),
-    name: z20.string().optional(),
-    peer: z20.string().optional(),
-    time: z20.string().optional(),
-    summary: z20.string().optional(),
-    status: z20.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
-    count: z20.number().int().positive().optional(),
-    recipients: z20.array(z20.string()).optional(),
-    reason: z20.string().optional(),
-    text: z20.string()
+    taskOp: z21.enum(TRANSMISSION_OPS).optional(),
+    outgoing: z21.literal(true).optional(),
+    name: z21.string().optional(),
+    peer: z21.string().optional(),
+    time: z21.string().optional(),
+    summary: z21.string().optional(),
+    status: z21.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
+    count: z21.number().int().positive().optional(),
+    recipients: z21.array(z21.string()).optional(),
+    reason: z21.string().optional(),
+    text: z21.string()
   })
 ]);
 
 // ../protocol/src/mobile.ts
-import { z as z21 } from "zod";
-var RelayUrlSchema = z21.string().transform((v, ctx) => {
+import { z as z22 } from "zod";
+var RelayUrlSchema = z22.string().transform((v, ctx) => {
   const bad = () => {
-    ctx.addIssue({ code: z21.ZodIssueCode.custom, message: "invalid relay URL" });
-    return z21.NEVER;
+    ctx.addIssue({ code: z22.ZodIssueCode.custom, message: "invalid relay URL" });
+    return z22.NEVER;
   };
   let u;
   try {
@@ -1185,116 +1213,122 @@ var RelayUrlSchema = z21.string().transform((v, ctx) => {
   if (u.username || u.password || u.pathname !== "/" || u.search || u.hash) return bad();
   return u.origin;
 });
-var MobileConfigSchema = z21.object({ enabled: z21.boolean(), relayUrl: RelayUrlSchema });
-var MobileLinkStateSchema = z21.discriminatedUnion("state", [
-  z21.object({ state: z21.literal("off") }),
-  z21.object({ state: z21.literal("connecting") }),
-  z21.object({ state: z21.literal("online") }),
-  z21.object({ state: z21.literal("offline"), retryAt: z21.string().datetime(), error: z21.string() }),
-  z21.object({ state: z21.literal("signed_out"), reason: z21.enum(["other_pc", "session_invalid"]) }),
+var MobileConfigSchema = z22.object({ enabled: z22.boolean(), relayUrl: RelayUrlSchema, terminalInput: z22.boolean().optional() });
+var MobileLinkStateSchema = z22.discriminatedUnion("state", [
+  z22.object({ state: z22.literal("off") }),
+  z22.object({ state: z22.literal("connecting") }),
+  z22.object({ state: z22.literal("online") }),
+  z22.object({ state: z22.literal("offline"), retryAt: z22.string().datetime(), error: z22.string() }),
+  z22.object({ state: z22.literal("signed_out"), reason: z22.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. */
-  z21.object({ state: z21.literal("unavailable"), error: z21.string().max(200) })
+  z22.object({ state: z22.literal("unavailable"), error: z22.string().max(200) })
 ]);
-var MobilePairingSchema = z21.object({
-  id: z21.string(),
-  label: z21.string(),
-  code: z21.string().nullable(),
-  expiresAt: z21.string().datetime(),
-  state: z21.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
-});
-var MobileStateSchema = z21.object({
-  enabled: z21.boolean(),
-  relayUrl: z21.string(),
-  account: z21.object({ login: z21.string(), accountId: z21.string() }).nullable(),
-  signin: z21.object({ userCode: z21.string(), verificationUri: z21.string(), expiresAt: z21.string().datetime() }).nullable(),
+var MobilePairingSchema = z22.object({
+  id: z22.string(),
+  label: z22.string(),
+  code: z22.string().nullable(),
+  expiresAt: z22.string().datetime(),
+  state: z22.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
+});
+var MobileStateSchema = z22.object({
+  enabled: z22.boolean(),
+  relayUrl: z22.string(),
+  account: z22.object({ login: z22.string(), accountId: z22.string() }).nullable(),
+  signin: z22.object({ userCode: z22.string(), verificationUri: z22.string(), expiresAt: z22.string().datetime() }).nullable(),
   /** The last sign-in that did not end with a session; cleared by the next one. */
-  signinError: z21.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
+  signinError: z22.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
   link: MobileLinkStateSchema,
-  devices: z21.array(z21.object({ id: z21.string(), label: z21.string(), approvedAt: z21.string(), online: z21.boolean(), lastSeenAt: z21.string().optional() })),
-  pairings: z21.array(MobilePairingSchema)
+  devices: z22.array(z22.object({ id: z22.string(), label: z22.string(), approvedAt: z22.string(), online: z22.boolean(), lastSeenAt: z22.string().optional() })),
+  pairings: z22.array(MobilePairingSchema),
+  /** « Taper dans les terminaux depuis le téléphone »: absent from an older daemon, which has no phone terminal. */
+  terminalInput: z22.boolean().optional()
 });
 
 // ../protocol/src/messages.ts
-var RefusalCodeSchema = z22.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 = z22.object({
-  name: z22.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: z22.string().datetime(),
-  source: z22.enum(["hook", "pane", "daemon"]),
-  tool: z22.string().optional(),
-  text: z22.string().optional(),
-  options: z22.array(z22.string()).optional(),
+var RefusalCodeSchema = z23.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 = z23.object({
+  name: z23.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: z23.string().datetime(),
+  source: z23.enum(["hook", "pane", "daemon"]),
+  tool: z23.string().optional(),
+  text: z23.string().optional(),
+  options: z23.array(z23.string()).optional(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z22.array(z22.string()).optional(),
-  kind: z22.enum(["question", "permission", "plan", "diff"]).optional(),
+  optionDetails: z23.array(z23.string()).optional(),
+  kind: z23.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: z22.string().optional(),
-  exitCode: z22.number().int().nullable().optional(),
-  helperId: z22.string().optional(),
+  body: z23.string().optional(),
+  exitCode: z23.number().int().nullable().optional(),
+  helperId: z23.string().optional(),
   /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z22.string().optional(),
+  task: z23.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z22.boolean().optional(),
+  interrupt: z23.boolean().optional(),
   /** UserPromptSubmit, PostToolUse: the images the prompt or the tool result carried, by attachment id. */
-  attachments: z22.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+  attachments: z23.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
   /** PostToolUse: some of the result's images were not kept. */
-  imagesDropped: z22.boolean().optional(),
+  imagesDropped: z23.boolean().optional(),
   /** QueueUpdate: OMP's queue as it stands. */
-  queue: z22.array(z22.object({ text: z22.string(), mode: z22.enum(["steer", "follow_up"]) })).optional(),
+  queue: z23.array(z23.object({ text: z23.string(), mode: z23.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: z22.string().optional(),
-  streaming: z22.boolean().optional(),
+  messageId: z23.string().optional(),
+  streaming: z23.boolean().optional(),
   /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
-  requestId: z22.string().optional(),
-  questions: z22.array(AskQuestionSchema).optional(),
+  requestId: z23.string().optional(),
+  questions: z23.array(AskQuestionSchema).optional(),
   /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
-  streamed: z22.boolean().optional(),
+  streamed: z23.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: z22.string().optional(),
+  toolUseId: z23.string().optional(),
   /** The tool's input as the harness gave it, every string capped by the hook. */
-  toolInput: z22.record(z22.string(), z22.unknown()).optional(),
+  toolInput: z23.record(z23.string(), z23.unknown()).optional(),
   /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z22.string().optional(),
-  durationMs: z22.number().nonnegative().optional(),
+  output: z23.string().optional(),
+  durationMs: z23.number().nonnegative().optional(),
   /** PostToolUseFailure: the harness's error message. */
-  error: z22.string().optional(),
+  error: z23.string().optional(),
   /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
-  transcriptPath: z22.string().optional(),
+  transcriptPath: z23.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: z22.literal(true).optional(),
+  byClose: z23.literal(true).optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
-  agentSessionId: z22.string().optional()
+  agentSessionId: z23.string().optional()
 });
-var RecentSchema = z22.object({ cwd: z22.string().min(1), project: z22.string().min(1), lastAt: z22.string().datetime() });
+var RecentSchema = z23.object({ cwd: z23.string().min(1), project: z23.string().min(1), lastAt: z23.string().datetime() });
 var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z22.object({
-  version: z22.string(),
-  install: z22.enum(["npm", "git", "unknown"]),
-  systemd: z22.boolean(),
-  manual: z22.string().optional(),
-  routing: z22.boolean().optional(),
-  archive: z22.boolean().optional(),
+var DaemonInfoSchema = z23.object({
+  version: z23.string(),
+  install: z23.enum(["npm", "git", "unknown"]),
+  systemd: z23.boolean(),
+  manual: z23.string().optional(),
+  routing: z23.boolean().optional(),
+  archive: z23.boolean().optional(),
   /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
-  models: z22.boolean().optional(),
+  models: z23.boolean().optional(),
   /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
-  omp: z22.boolean().optional(),
+  omp: z23.boolean().optional(),
   /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
-  modelSwitch: z22.boolean().optional(),
+  modelSwitch: z23.boolean().optional(),
+  /** Answers `session.commands`: the slash commands a session's agent offers. */
+  commands: z23.boolean().optional(),
   /** Takes `approval` on an OMP `session.launch` (auto mode). */
-  ompApproval: z22.boolean().optional(),
+  ompApproval: z23.boolean().optional(),
   /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
-  home: z22.string().optional(),
-  mobile: z22.boolean().optional(),
+  home: z23.string().optional(),
+  mobile: z23.boolean().optional(),
   /** Answers `openrig.status` and `openrig.act`: drives OpenRig on its machine. */
-  openrig: z22.boolean().optional(),
+  openrig: z23.boolean().optional(),
   /** Answers `openrig.roles`, `openrig.role` and `openrig.roleFile`: reads OpenRig's roles (agent specs). */
-  openrigRoles: z22.boolean().optional()
+  openrigRoles: z23.boolean().optional(),
+  /** Takes `session.broadcast` (its `ledge bridge` too, on this machine): a client sends it only when this is set. */
+  broadcast: z23.boolean().optional()
 });
-var UpdateFailureSchema = z22.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z22.discriminatedUnion("type", [
+var UpdateFailureSchema = z23.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z23.discriminatedUnion("type", [
   SessionModelAcceptedSchema,
-  z22.object({ type: z22.literal("chat.routed"), qid: z22.string(), result: RouteResultSchema }),
+  z23.object({ type: z23.literal("chat.routed"), qid: z23.string(), result: RouteResultSchema }),
   DocumentContentSchema,
   DocumentErrorSchema,
   AttachmentStoredSchema,
@@ -1303,6 +1337,7 @@ var ServerMessageSchema = z22.discriminatedUnion("type", [
   ReposInfoSchema,
   ReposFoundSchema,
   ModelsListingSchema,
+  SessionCommandsListingSchema,
   OpenRigStateMessageSchema,
   OpenRigDoneSchema,
   OpenRigSpecListSchema,
@@ -1314,94 +1349,105 @@ var ServerMessageSchema = z22.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. */
-  z22.object({ type: z22.literal("snapshot"), sessions: z22.array(SessionSchema), recents: z22.array(RecentSchema).optional(), launcher: z22.array(z22.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
-  z22.object({ type: z22.literal("session.updated"), session: SessionSchema }),
+  z23.object({ type: z23.literal("snapshot"), sessions: z23.array(SessionSchema), recents: z23.array(RecentSchema).optional(), launcher: z23.array(z23.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z23.object({ type: z23.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. */
-  z22.object({
-    type: z22.literal("session.queue.restored"),
-    id: z22.string(),
-    texts: z22.array(z22.string()),
+  z23.object({
+    type: z23.literal("session.queue.restored"),
+    id: z23.string(),
+    texts: z23.array(z23.string()),
     /** The same instructions with the images they carried; `imagesDropped`: some images could not be put back. */
-    entries: z22.array(z22.object({ text: z22.string(), attachments: z22.array(AttachmentIdSchema).optional() })).optional(),
-    imagesDropped: z22.boolean().optional()
+    entries: z23.array(z23.object({ text: z23.string(), attachments: z23.array(AttachmentIdSchema).optional() })).optional(),
+    imagesDropped: z23.boolean().optional()
   }),
-  z22.object({ type: z22.literal("session.removed"), id: z22.string() }),
-  z22.object({ type: z22.literal("session.preview"), id: z22.string(), lines: z22.array(z22.string()) }),
+  z23.object({ type: z23.literal("session.removed"), id: z23.string() }),
+  z23.object({ type: z23.literal("session.preview"), id: z23.string(), lines: z23.array(z23.string()) }),
   /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
-  z22.object({ type: z22.literal("session.thread"), id: z22.string(), items: z22.array(ThreadItemSchema) }),
-  z22.object({ type: z22.literal("session.thread.item"), id: z22.string(), item: ThreadItemSchema }),
+  z23.object({ type: z23.literal("session.thread"), id: z23.string(), items: z23.array(ThreadItemSchema) }),
+  z23.object({ type: z23.literal("session.thread.item"), id: z23.string(), item: ThreadItemSchema }),
   /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
-  z22.object({ type: z22.literal("session.launched"), id: z22.string() }),
+  z23.object({ type: z23.literal("session.launched"), id: z23.string() }),
   /** Answer to the requester of a `session.close`, once per row closed: the session `id` and how it ended. */
-  z22.object({ type: z22.literal("session.closed"), qid: z22.string(), row: z22.number().int().min(0), id: z22.string(), how: z22.enum(["exit", "killed"]) }),
-  z22.object({ type: z22.literal("recents"), recents: z22.array(RecentSchema) }),
+  z23.object({ type: z23.literal("session.closed"), qid: z23.string(), row: z23.number().int().min(0), id: z23.string(), how: z23.enum(["exit", "killed"]) }),
+  z23.object({ type: z23.literal("recents"), recents: z23.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. */
-  z22.object({
-    type: z22.literal("folder.listing"),
-    path: z22.string(),
-    parent: z22.string().nullable(),
-    entries: z22.array(z22.string()),
-    error: z22.string().optional(),
+  z23.object({
+    type: z23.literal("folder.listing"),
+    path: z23.string(),
+    parent: z23.string().nullable(),
+    entries: z23.array(z23.string()),
+    error: z23.string().optional(),
     /** The request this answers, when it carried one. */
-    requestId: z22.string().optional(),
+    requestId: z23.string().optional(),
     /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
-    repos: z22.array(z22.object({ name: z22.string(), branch: z22.string() })).optional()
+    repos: z23.array(z23.object({ name: z23.string(), branch: z23.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. */
-  z22.object({ type: z22.literal("chat.step"), qid: z22.string(), step: ChatStepSchema }),
-  z22.object({ type: z22.literal("chat.delta"), qid: z22.string(), text: z22.string() }),
-  z22.object({ type: z22.literal("chat.done"), qid: z22.string(), text: z22.string(), at: z22.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), tasks: ChatTasksSchema.optional(), actions: ChatActionsSchema.optional() }),
+  z23.object({ type: z23.literal("chat.step"), qid: z23.string(), step: ChatStepSchema }),
+  z23.object({ type: z23.literal("chat.delta"), qid: z23.string(), text: z23.string() }),
+  z23.object({ type: z23.literal("chat.done"), qid: z23.string(), text: z23.string(), at: z23.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.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). */
-  z22.object({ type: z22.literal("chat.acted"), rid: z22.string(), qid: z22.string(), done: z22.array(z22.number().int().min(0)), failed: z22.array(z22.object({
-    row: z22.number().int().min(0),
-    message: z22.string(),
+  z23.object({ type: z23.literal("chat.acted"), rid: z23.string(), qid: z23.string(), done: z23.array(z23.number().int().min(0)), failed: z23.array(z23.object({
+    row: z23.number().int().min(0),
+    message: z23.string(),
     /** nothing was sent */
-    refused: z22.literal(true).optional()
+    refused: z23.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). */
-  z22.object({ type: z22.literal("action.result"), rid: z22.string(), action: z22.string().min(1).max(40), row: ChatActionSchema.optional(), reason: z22.string().optional(), code: z22.string().optional() }),
-  z22.object({ type: z22.literal("chat.error"), qid: z22.string(), message: z22.string() }),
-  z22.object({ type: z22.literal("chat.history"), turns: z22.array(ChatTurnSchema) }),
+  z23.object({ type: z23.literal("action.result"), rid: z23.string(), action: z23.string().min(1).max(40), row: ChatActionSchema.optional(), reason: z23.string().optional(), code: z23.string().optional() }),
+  z23.object({ type: z23.literal("chat.error"), qid: z23.string(), message: z23.string() }),
+  z23.object({ type: z23.literal("chat.history"), turns: z23.array(ChatTurnSchema) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
-  z22.object({ type: z22.literal("update.progress"), version: z22.string(), step: z22.enum(["installing", "restarting"]) }),
+  z23.object({ type: z23.literal("update.progress"), version: z23.string(), step: z23.enum(["installing", "restarting"]) }),
   /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
-  z22.object({ type: z22.literal("update.failed"), version: z22.string(), reason: UpdateFailureSchema, detail: z22.string().optional(), command: z22.string().optional() }),
+  z23.object({ type: z23.literal("update.failed"), version: z23.string(), reason: UpdateFailureSchema, detail: z23.string().optional(), command: z23.string().optional() }),
   /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z22.object({ type: z22.literal("machines"), machines: MachinesSchema }),
+  z23.object({ type: z23.literal("machines"), machines: MachinesSchema }),
   /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
-  z22.object({ type: z22.literal("projects"), projects: ProjectsSchema }),
+  z23.object({ type: z23.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. */
-  z22.object({ type: z22.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  z23.object({ type: z23.literal("island"), prefs: IslandPrefsSchema.nullable() }),
   /** Mobile access (lot 3), after the island in each snapshot and on every change. Local clients only. */
-  z22.object({ type: z22.literal("mobile"), state: MobileStateSchema }),
+  z23.object({ type: z23.literal("mobile"), state: MobileStateSchema }),
+  /** The sessions a phone types into (« Téléphone au clavier »), after each snapshot and each change; `device` is its label. */
+  z23.object({ type: z23.literal("terminal.holders"), holds: z23.array(z23.object({ id: z23.string(), device: z23.string() })) }),
   /** 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`. */
-  z22.object({ type: z22.literal("message.ack"), rid: z22.string(), outcome: z22.enum(["accepted", "queued", "native", "refused"]), reason: z22.string().optional() }),
+  z23.object({
+    type: z23.literal("message.ack"),
+    rid: z23.string(),
+    outcome: z23.enum(["accepted", "queued", "native", "refused"]),
+    reason: z23.string().optional(),
+    /** A broadcast's per-recipient outcome, by name. */
+    recipients: z23.object({ sent: z23.array(z23.string()), refused: z23.array(z23.object({ name: z23.string(), reason: z23.string() })) }).optional()
+  }),
+  /** The answer to a `session.broadcast`: who got it (`sent`) and who did not; `reason`: the whole broadcast was refused. */
+  z23.object({ type: z23.literal("session.broadcast.result"), rid: z23.string(), sent: z23.array(z23.object({ id: z23.string(), name: z23.string() })), refused: z23.array(z23.object({ name: z23.string(), reason: z23.string() })), reason: z23.string().optional() }),
   /** The answer to a `message.read`: the body with its sender, target and time, or the refusal's `reason`. */
-  z22.object({ type: z22.literal("message.body"), id: z22.string(), from: z22.string().optional(), to: z22.string().optional(), at: z22.string().optional(), text: z22.string().optional(), reason: z22.string().optional() }),
+  z23.object({ type: z23.literal("message.body"), id: z23.string(), from: z23.string().optional(), to: z23.string().optional(), at: z23.string().optional(), text: z23.string().optional(), reason: z23.string().optional() }),
   TaskResultSchema,
   SessionHandoverResultSchema,
   ContextPrefsMessageSchema,
   HandoverResultSchema,
   TaskUpdatedSchema,
-  z22.object({
-    type: z22.literal("error"),
-    message: z22.string(),
-    id: z22.string().optional(),
+  z23.object({
+    type: z23.literal("error"),
+    message: z23.string(),
+    id: z23.string().optional(),
     /** Le type du message client refusé. */
-    request: z22.string().optional(),
+    request: z23.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: z22.string().optional()
+    code: z23.string().optional()
   })
 ]);
 var MESSAGE_MAX = 2e4;
 var SUMMARY_MAX = 500;
-var launchRows = z22.array(z22.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 = z22.discriminatedUnion("type", [
-  z22.object({ type: z22.literal("chat.route"), qid: z22.string().min(1).max(100), text: z22.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+var launchRows = z23.array(z23.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 = z23.discriminatedUnion("type", [
+  z23.object({ type: z23.literal("chat.route"), qid: z23.string().min(1).max(100), text: z23.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
   AttachmentPutSchema,
   AttachmentCaptureSchema,
@@ -1409,6 +1455,7 @@ var ClientMessageSchema = z22.discriminatedUnion("type", [
   ReposInspectSchema,
   ReposScanSchema,
   ModelsListSchema,
+  SessionCommandsSchema,
   OpenRigStatusSchema,
   OpenRigActSchema,
   OpenRigSpecsSchema,
@@ -1421,151 +1468,165 @@ var ClientMessageSchema = z22.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`. */
-  z22.object({
-    type: z22.literal("session.launch"),
+  z23.object({
+    type: z23.literal("session.launch"),
     tool: ToolSchema,
-    cwd: z22.string().min(1),
-    name: z22.string().optional(),
-    prompt: z22.string().optional(),
-    continue: z22.boolean().optional(),
-    qid: z22.string().min(1).optional(),
+    cwd: z23.string().min(1),
+    name: z23.string().optional(),
+    prompt: z23.string().optional(),
+    continue: z23.boolean().optional(),
+    qid: z23.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: z22.array(z22.string().min(1)).max(20).optional(),
+    dirs: z23.array(z23.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: z22.string().optional()
+    machineId: z23.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`. */
-  z22.object({
-    type: z22.literal("folder.list"),
-    path: z22.string().optional(),
+  z23.object({
+    type: z23.literal("folder.list"),
+    path: z23.string().optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z22.string().optional(),
+    machineId: z23.string().optional(),
     /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
-    requestId: z22.string().min(1).max(100).optional()
+    requestId: z23.string().min(1).max(100).optional()
   }),
-  z22.object({
-    type: z22.literal("folder.create"),
-    parent: z22.string().min(1),
-    name: z22.string().min(1),
+  z23.object({
+    type: z23.literal("folder.create"),
+    parent: z23.string().min(1),
+    name: z23.string().min(1),
     /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
-    machineId: z22.string().optional(),
-    requestId: z22.string().min(1).max(100).optional()
+    machineId: z23.string().optional(),
+    requestId: z23.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. */
-  z22.object({ type: z22.literal("session.answer"), id: z22.string(), requestId: z22.string().min(1).max(200), answers: z22.array(z22.object({ id: z22.string(), selected: z22.array(z22.string().max(2e3)).max(100), text: z22.string().max(2e4).optional() })).max(50), cancel: z22.boolean().optional() }),
-  z22.object({ type: z22.literal("session.reply"), id: z22.string(), text: z22.string(), attachments: z22.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(), steer: z22.boolean().optional() }),
+  z23.object({ type: z23.literal("session.answer"), id: z23.string(), requestId: z23.string().min(1).max(200), answers: z23.array(z23.object({ id: z23.string(), selected: z23.array(z23.string().max(2e3)).max(100), text: z23.string().max(2e4).optional() })).max(50), cancel: z23.boolean().optional() }),
+  z23.object({ type: z23.literal("session.reply"), id: z23.string(), text: z23.string(), attachments: z23.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(), steer: z23.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. */
-  z22.object({ type: z22.literal("session.relay"), qid: z22.string().min(1) }),
+  z23.object({ type: z23.literal("session.relay"), qid: z23.string().min(1) }),
   /** Takes the card's queued instruction back out of the queue. */
-  z22.object({ type: z22.literal("session.relay.cancel"), qid: z22.string().min(1) }),
+  z23.object({ type: z23.literal("session.relay.cancel"), qid: z23.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. */
-  z22.object({
-    type: z22.literal("chat.act"),
-    rid: z22.string().min(1).max(100),
-    qid: z22.string().min(1),
+  z23.object({
+    type: z23.literal("chat.act"),
+    rid: z23.string().min(1).max(100),
+    qid: z23.string().min(1),
     rows: launchRows.optional(),
-    confirmed: z22.literal(true).optional(),
+    confirmed: z23.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: z22.literal(true).optional()
+    deny: z23.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. */
-  z22.object({ type: z22.literal("chat.ignore"), qid: z22.string().min(1), undo: z22.literal(true).optional() }),
+  z23.object({ type: z23.literal("chat.ignore"), qid: z23.string().min(1), undo: z23.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. */
-  z22.object({
-    type: z22.literal("action.run"),
-    rid: z22.string().min(1).max(100),
-    by: z22.string().min(1).optional(),
+  z23.object({
+    type: z23.literal("action.run"),
+    rid: z23.string().min(1).max(100),
+    by: z23.string().min(1).optional(),
     /** `by`'s key (LEDGE_SESSION_KEY) */
-    key: z22.string().max(128).optional(),
+    key: z23.string().max(128).optional(),
     action: ActionIdSchema,
-    args: z22.record(z22.unknown()),
-    confirmed: z22.literal(true).optional()
+    args: z23.record(z23.unknown()),
+    confirmed: z23.literal(true).optional()
   }),
   /** The chat's close card: closes the turn's sessions, `rows` (indexes into its `closes`) or all of them. */
-  z22.object({ type: z22.literal("session.close"), qid: z22.string().min(1), rows: launchRows.optional() }),
+  z23.object({ type: z23.literal("session.close"), qid: z23.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. */
-  z22.object({
-    type: z22.literal("session.decide"),
-    id: z22.string(),
+  z23.object({
+    type: z23.literal("session.decide"),
+    id: z23.string(),
     decision: DecisionSchema,
-    note: z22.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z23.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: z22.string().max(64).optional() }).optional()
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z23.string().max(64).optional() }).optional()
   }),
-  z22.object({ type: z22.literal("session.focus"), id: z22.string() }),
-  z22.object({ type: z22.literal("session.kill"), id: z22.string() }),
+  z23.object({ type: z23.literal("session.focus"), id: z23.string() }),
+  z23.object({ type: z23.literal("session.kill"), id: z23.string() }),
   /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
-  z22.object({ type: z22.literal("session.interrupt"), id: z22.string(), restoreQueue: z22.boolean().optional() }),
+  z23.object({ type: z23.literal("session.interrupt"), id: z23.string(), restoreQueue: z23.boolean().optional() }),
   /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
-  z22.object({ type: z22.literal("session.dismiss"), id: z22.string() }),
+  z23.object({ type: z23.literal("session.dismiss"), id: z23.string() }),
   /** Puts a session in the archive: it leaves the live list but is kept. */
-  z22.object({ type: z22.literal("session.archive"), id: z22.string() }),
+  z23.object({ type: z23.literal("session.archive"), id: z23.string() }),
   /** Takes an archived session back out of the archive, as it was. */
-  z22.object({ type: z22.literal("session.restore"), id: z22.string() }),
+  z23.object({ type: z23.literal("session.restore"), id: z23.string() }),
   /** Starts the agent again on an archived session's conversation. */
-  z22.object({ type: z22.literal("session.resume"), id: z22.string() }),
+  z23.object({ type: z23.literal("session.resume"), id: z23.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. */
-  z22.object({ type: z22.literal("session.model"), id: z22.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  z23.object({ type: z23.literal("session.model"), id: z23.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** Deletes a session for good, archived or not. */
-  z22.object({ type: z22.literal("session.delete"), id: z22.string() }),
+  z23.object({ type: z23.literal("session.delete"), id: z23.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. */
-  z22.object({ type: z22.literal("session.rename"), id: z22.string(), topic: z22.string().max(500) }),
-  z22.object({ type: z22.literal("session.thread"), id: z22.string() }),
-  z22.object({ type: z22.literal("session.register"), session: SessionSchema }),
+  z23.object({ type: z23.literal("session.rename"), id: z23.string(), topic: z23.string().max(500) }),
+  z23.object({ type: z23.literal("session.thread"), id: z23.string() }),
+  z23.object({ type: z23.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). */
-  z22.object({
-    type: z22.literal("session.event"),
-    id: z22.string(),
+  z23.object({
+    type: z23.literal("session.event"),
+    id: z23.string(),
     event: SessionEventSchema,
     agent: ToolSchema.optional(),
-    cwd: z22.string().optional(),
+    cwd: z23.string().optional(),
     /** The OpenRig seat the agent runs in (`OPENRIG_SESSION_NAME`, `pod-member@rig`), when OpenRig launched it. */
     rigSeat: RigSeatNameSchema.optional()
   }),
-  z22.object({ type: z22.literal("session.unregister"), id: z22.string(), exitCode: z22.number().int().nullable() }),
-  z22.object({ type: z22.literal("snapshot.request") }),
-  z22.object({ type: z22.literal("chat.ask"), qid: z22.string().min(1), text: z22.string(), images: z22.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
-  z22.object({ type: z22.literal("chat.cancel"), qid: z22.string().min(1) }),
+  z23.object({ type: z23.literal("session.unregister"), id: z23.string(), exitCode: z23.number().int().nullable() }),
+  z23.object({ type: z23.literal("snapshot.request") }),
+  z23.object({ type: z23.literal("chat.ask"), qid: z23.string().min(1), text: z23.string(), images: z23.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
+  z23.object({ type: z23.literal("chat.cancel"), qid: z23.string().min(1) }),
   /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
-  z22.object({ type: z22.literal("chat.reset") }),
+  z23.object({ type: z23.literal("chat.reset") }),
   /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
-  z22.object({ type: z22.literal("update.daemon"), version: z22.string().regex(SEMVER) }),
+  z23.object({ type: z23.literal("update.daemon"), version: z23.string().regex(SEMVER) }),
   /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
-  z22.object({ type: z22.literal("machines.set"), machines: MachinesSchema }),
+  z23.object({ type: z23.literal("machines.set"), machines: MachinesSchema }),
   /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
-  z22.object({ type: z22.literal("projects.set"), projects: ProjectsSchema }),
+  z23.object({ type: z23.literal("projects.set"), projects: ProjectsSchema }),
   /** Replaces the island's settings as a whole; refused unless valid. */
-  z22.object({ type: z22.literal("island.set"), prefs: IslandPrefsSchema }),
+  z23.object({ type: z23.literal("island.set"), prefs: IslandPrefsSchema }),
   /** Mobile access (lot 3), local fronts only. A changed `relayUrl` drops the relay session. */
-  z22.object({ type: z22.literal("mobile.set"), enabled: z22.boolean(), relayUrl: RelayUrlSchema }),
-  z22.object({ type: z22.literal("mobile.signin") }),
-  z22.object({ type: z22.literal("mobile.signin.cancel") }),
-  z22.object({ type: z22.literal("mobile.signout") }),
+  z23.object({ type: z23.literal("mobile.set"), enabled: z23.boolean(), relayUrl: RelayUrlSchema }),
+  z23.object({ type: z23.literal("mobile.signin") }),
+  z23.object({ type: z23.literal("mobile.signin.cancel") }),
+  z23.object({ type: z23.literal("mobile.signout") }),
   /** While the link is offline: try again now. */
-  z22.object({ type: z22.literal("mobile.retry") }),
-  z22.object({ type: z22.literal("mobile.pairing.approve"), id: z22.string().min(1).max(100) }),
-  z22.object({ type: z22.literal("mobile.pairing.deny"), id: z22.string().min(1).max(100) }),
+  z23.object({ type: z23.literal("mobile.retry") }),
+  z23.object({ type: z23.literal("mobile.pairing.approve"), id: z23.string().min(1).max(100) }),
+  z23.object({ type: z23.literal("mobile.pairing.deny"), id: z23.string().min(1).max(100) }),
   /** `id`: the device's fingerprint. */
-  z22.object({ type: z22.literal("mobile.device.revoke"), id: z22.string().min(1).max(100) }),
+  z23.object({ type: z23.literal("mobile.device.revoke"), id: z23.string().min(1).max(100) }),
+  /** « Taper dans les terminaux depuis le téléphone »; turned off, every phone loses the hand. */
+  z23.object({ type: z23.literal("mobile.terminal"), input: z23.boolean() }),
+  /** « Reprendre la main »: the phone typing into the session's terminal goes back to reading it. */
+  z23.object({ type: z23.literal("terminal.release"), id: z23.string().min(1) }),
   /** 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. */
-  z22.object({ type: z22.literal("session.message"), rid: z22.string().min(1), from: z22.string().min(1), to: z22.string().min(1), text: z22.string().min(1).max(MESSAGE_MAX), summary: z22.string().max(SUMMARY_MAX).optional(), intercept: z22.boolean().optional() }),
+  z23.object({ type: z23.literal("session.message"), rid: z23.string().min(1), from: z23.string().min(1), to: z23.string().min(1), text: z23.string().min(1).max(MESSAGE_MAX), summary: z23.string().max(SUMMARY_MAX).optional(), intercept: z23.boolean().optional() }),
+  /** The user writing to every session of a project, or to several sessions (ids or names). */
+  z23.object({
+    type: z23.literal("session.broadcast"),
+    rid: z23.string().min(1).max(100),
+    to: z23.union([z23.object({ project: z23.string().min(1).max(80) }), z23.object({ sessions: z23.array(z23.string().min(1)).min(1).max(BROADCAST_SESSIONS_MAX) })]),
+    text: z23.string().trim().min(1).max(MESSAGE_MAX),
+    summary: z23.string().max(SUMMARY_MAX).optional(),
+    /** How the recipients are told who it went to (« (à <label>) »), instead of the names: a project the fleet turned into sessions. */
+    label: z23.string().min(1).max(BROADCAST_LABEL_MAX).optional()
+  }),
   /** `ledge read <id>`: a message's whole body, for its receiver or its sender (`by`, a session id). */
-  z22.object({ type: z22.literal("message.read"), id: z22.string().min(1).max(40), by: z22.string().min(1) }),
+  z23.object({ type: z23.literal("message.read"), id: z23.string().min(1).max(40), by: z23.string().min(1) }),
   TaskCmdSchema,
   SessionHandoverSchema,
   ContextSetSchema,
@@ -1574,79 +1635,79 @@ var ClientMessageSchema = z22.discriminatedUnion("type", [
 ]);
 
 // ../protocol/src/relay.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var SEALED_MAX = 1048576;
-var RelayPeerSchema = z23.union([z23.literal("pc"), z23.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
-var RelayClientMessageSchema = z23.object({
-  type: z23.literal("send"),
+var RelayPeerSchema = z24.union([z24.literal("pc"), z24.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
+var RelayClientMessageSchema = z24.object({
+  type: z24.literal("send"),
   to: RelayPeerSchema,
-  body: z23.string().max(SEALED_MAX)
+  body: z24.string().max(SEALED_MAX)
 });
-var RelayServerMessageSchema = z23.discriminatedUnion("type", [
-  z23.object({ type: z23.literal("welcome"), accountId: z23.string(), self: RelayPeerSchema, online: z23.array(RelayPeerSchema) }),
-  z23.object({ type: z23.literal("deliver"), from: RelayPeerSchema, body: z23.string() }),
-  z23.object({ type: z23.literal("presence"), peer: RelayPeerSchema, online: z23.boolean() }),
+var RelayServerMessageSchema = z24.discriminatedUnion("type", [
+  z24.object({ type: z24.literal("welcome"), accountId: z24.string(), self: RelayPeerSchema, online: z24.array(RelayPeerSchema) }),
+  z24.object({ type: z24.literal("deliver"), from: RelayPeerSchema, body: z24.string() }),
+  z24.object({ type: z24.literal("presence"), peer: RelayPeerSchema, online: z24.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.
    */
-  z23.object({
-    type: z23.literal("error"),
-    code: z23.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
+  z24.object({
+    type: z24.literal("error"),
+    code: z24.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
     to: RelayPeerSchema.optional()
   })
 ]);
 var PAIR_LABEL_MAX = 40;
-var KeyB64 = z23.string().regex(/^[A-Za-z0-9_-]{87}$/);
-var Nonce = z23.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var Fingerprint = z23.string().regex(/^[A-Za-z0-9_-]{22}$/);
-var SealedFrameSchema = z23.discriminatedUnion("k", [
+var KeyB64 = z24.string().regex(/^[A-Za-z0-9_-]{87}$/);
+var Nonce = z24.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var Fingerprint = z24.string().regex(/^[A-Za-z0-9_-]{22}$/);
+var SealedFrameSchema = z24.discriminatedUnion("k", [
   /** `e` is the ephemeral key, `f` the fingerprint of the sender's static key. */
-  z23.object({ k: z23.literal("hello"), e: KeyB64, f: Fingerprint }),
-  z23.object({ k: z23.literal("msg"), s: z23.string() }),
-  z23.object({ k: z23.literal("pair_commit"), c: Nonce, label: z23.string().trim().min(1).max(PAIR_LABEL_MAX) }),
-  z23.object({ k: z23.literal("pair_offer"), pc: KeyB64, n: Nonce }),
-  z23.object({ k: z23.literal("pair_reveal"), d: KeyB64, n: Nonce }),
-  z23.object({ k: z23.literal("pair_ok") }),
-  z23.object({ k: z23.literal("pair_no") }),
-  z23.object({ k: z23.literal("denied") }),
-  z23.object({ k: z23.literal("rekey") })
+  z24.object({ k: z24.literal("hello"), e: KeyB64, f: Fingerprint }),
+  z24.object({ k: z24.literal("msg"), s: z24.string() }),
+  z24.object({ k: z24.literal("pair_commit"), c: Nonce, label: z24.string().trim().min(1).max(PAIR_LABEL_MAX) }),
+  z24.object({ k: z24.literal("pair_offer"), pc: KeyB64, n: Nonce }),
+  z24.object({ k: z24.literal("pair_reveal"), d: KeyB64, n: Nonce }),
+  z24.object({ k: z24.literal("pair_ok") }),
+  z24.object({ k: z24.literal("pair_no") }),
+  z24.object({ k: z24.literal("denied") }),
+  z24.object({ k: z24.literal("rekey") })
 ]);
 
 // ../protocol/src/relayAuth.ts
-import { z as z24 } from "zod";
-var DeviceStartResponseSchema = z24.object({
-  deviceCode: z24.string().min(1),
-  userCode: z24.string().min(1),
-  verificationUri: z24.string().min(1),
-  expiresIn: z24.number().int().positive(),
-  interval: z24.number().int().positive()
-});
-var DevicePollResponseSchema = z24.discriminatedUnion("status", [
-  z24.object({ status: z24.literal("pending") }),
-  z24.object({ status: z24.literal("slow_down"), interval: z24.number().int().positive() }),
+import { z as z25 } from "zod";
+var DeviceStartResponseSchema = z25.object({
+  deviceCode: z25.string().min(1),
+  userCode: z25.string().min(1),
+  verificationUri: z25.string().min(1),
+  expiresIn: z25.number().int().positive(),
+  interval: z25.number().int().positive()
+});
+var DevicePollResponseSchema = z25.discriminatedUnion("status", [
+  z25.object({ status: z25.literal("pending") }),
+  z25.object({ status: z25.literal("slow_down"), interval: z25.number().int().positive() }),
   /** `token` is the relay session token, shown this once only. */
-  z24.object({ status: z24.literal("ok"), token: z24.string().min(1), accountId: z24.string().min(1), login: z24.string().min(1) }),
-  z24.object({ status: z24.literal("expired") }),
-  z24.object({ status: z24.literal("denied") }),
-  z24.object({ status: z24.literal("not_allowed") })
+  z25.object({ status: z25.literal("ok"), token: z25.string().min(1), accountId: z25.string().min(1), login: z25.string().min(1) }),
+  z25.object({ status: z25.literal("expired") }),
+  z25.object({ status: z25.literal("denied") }),
+  z25.object({ status: z25.literal("not_allowed") })
 ]);
-var DeviceRevokeResponseSchema = z24.object({ revoked: z24.number().int().min(0) });
-var MeResponseSchema = z24.object({
-  accountId: z24.string().min(1),
-  login: z24.string().min(1),
+var DeviceRevokeResponseSchema = z25.object({ revoked: z25.number().int().min(0) });
+var MeResponseSchema = z25.object({
+  accountId: z25.string().min(1),
+  login: z25.string().min(1),
   peer: RelayPeerSchema,
-  kind: z24.enum(["pc", "device"])
+  kind: z25.enum(["pc", "device"])
 });
 
 // ../protocol/src/phone.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // ../protocol/src/push.ts
-import { z as z25 } from "zod";
-var B64U = z25.string().regex(/^[A-Za-z0-9_-]*$/);
+import { z as z26 } from "zod";
+var B64U = z26.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;
@@ -1663,29 +1724,29 @@ function pushEndpointAllowed(url) {
     return host.length > suffix.length && host.endsWith(suffix);
   });
 }
-var PushSendSchema = z25.object({
-  endpoint: z25.string().url().max(1024),
+var PushSendSchema = z26.object({
+  endpoint: z26.string().url().max(1024),
   body: B64U.max(5462),
-  ttl: z25.number().int().min(0).max(86400),
-  urgency: z25.enum(["normal", "high"]),
-  topic: z25.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
-});
-var PushSendResultSchema = z25.object({
-  result: z25.enum(["sent", "gone", "failed"]),
-  status: z25.number().int().optional()
-});
-var PushSubscriptionSchema = z25.object({
-  endpoint: z25.string().url().max(1024).refine(pushEndpointAllowed),
-  keys: z25.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
-});
-var PushPayloadSchema = z25.object({
-  v: z25.literal(1),
-  kind: z25.enum(["request", "question", "finished", "chat", "decision"]),
-  title: z25.string().max(80),
-  body: z25.string().max(120),
-  url: z25.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
-  badge: z25.number().int().min(0).max(999),
-  tag: z25.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+  ttl: z26.number().int().min(0).max(86400),
+  urgency: z26.enum(["normal", "high"]),
+  topic: z26.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+});
+var PushSendResultSchema = z26.object({
+  result: z26.enum(["sent", "gone", "failed"]),
+  status: z26.number().int().optional()
+});
+var PushSubscriptionSchema = z26.object({
+  endpoint: z26.string().url().max(1024).refine(pushEndpointAllowed),
+  keys: z26.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
+});
+var PushPayloadSchema = z26.object({
+  v: z26.literal(1),
+  kind: z26.enum(["request", "question", "finished", "chat", "decision"]),
+  title: z26.string().max(80),
+  body: z26.string().max(120),
+  url: z26.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
+  badge: z26.number().int().min(0).max(999),
+  tag: z26.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
 });
 
 // ../protocol/src/phone.ts
@@ -1695,35 +1756,35 @@ var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var CHECKLIST_TASKS_MAX = 50;
 var CHECKLIST_TEXT_MAX = 200;
-var ChecklistStatusSchema = z26.enum(["pending", "in_progress", "completed"]);
-var PhoneChecklistSchema = z26.object({
-  tasks: z26.array(z26.object({ text: z26.string().max(CHECKLIST_TEXT_MAX), status: ChecklistStatusSchema })).max(CHECKLIST_TASKS_MAX),
-  done: z26.number().int().nonnegative(),
-  total: z26.number().int().nonnegative(),
-  cut: z26.literal(true).optional()
-});
-var PhoneChecklistSummarySchema = z26.object({
-  done: z26.number().int().nonnegative(),
-  total: z26.number().int().nonnegative(),
-  current: z26.string().max(CHECKLIST_TEXT_MAX).optional(),
-  cut: z26.literal(true).optional()
-});
-var RiskSchema = z26.enum(["low", "high"]);
-var RiskReasonSchema = z26.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 = z26.string().uuid();
-var OperationStatusSchema = z26.enum(["received", "applied", "rejected", "failed"]);
-var OperationReasonSchema = z26.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired", "scheduled", ...ModelRefusalSchema.options]);
-var CapabilitiesSchema = z26.object({
+var ChecklistStatusSchema = z27.enum(["pending", "in_progress", "completed"]);
+var PhoneChecklistSchema = z27.object({
+  tasks: z27.array(z27.object({ text: z27.string().max(CHECKLIST_TEXT_MAX), status: ChecklistStatusSchema })).max(CHECKLIST_TASKS_MAX),
+  done: z27.number().int().nonnegative(),
+  total: z27.number().int().nonnegative(),
+  cut: z27.literal(true).optional()
+});
+var PhoneChecklistSummarySchema = z27.object({
+  done: z27.number().int().nonnegative(),
+  total: z27.number().int().nonnegative(),
+  current: z27.string().max(CHECKLIST_TEXT_MAX).optional(),
+  cut: z27.literal(true).optional()
+});
+var RiskSchema = z27.enum(["low", "high"]);
+var RiskReasonSchema = z27.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 = z27.string().uuid();
+var OperationStatusSchema = z27.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z27.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired", "scheduled", ...ModelRefusalSchema.options]);
+var CapabilitiesSchema = z27.object({
   /** A question can be answered in free text. */
-  freeTextAnswer: z26.boolean(),
+  freeTextAnswer: z27.boolean(),
   /** The session's accept/deny can be typed; absent = true. */
-  decide: z26.boolean().optional(),
+  decide: z27.boolean().optional(),
   /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z26.boolean().optional()
+  questions: z27.boolean().optional()
 });
-var CapabilitiesByToolSchema = z26.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
-var PhonePendingSchema = PendingSchema.extend({ key: z26.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z26.literal(true).optional() });
-var SwitchableSessionSchema = SessionSchema.extend({ canSwitch: z26.literal(true).optional() });
+var CapabilitiesByToolSchema = z27.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z27.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z27.literal(true).optional() });
+var SwitchableSessionSchema = SessionSchema.extend({ canSwitch: z27.literal(true).optional() });
 var PhoneSessionSchema = SwitchableSessionSchema.pick({
   id: true,
   name: true,
@@ -1751,288 +1812,346 @@ var PhoneSessionSchema = SwitchableSessionSchema.pick({
   exitedAt: true
 }).extend({
   pending: PhonePendingSchema.optional(),
-  unread: z26.boolean(),
-  handover: z26.object({ state: HandoverStateSchema, toName: z26.string().max(80).optional() }).strict().optional(),
+  unread: z27.boolean(),
+  handover: z27.object({ state: HandoverStateSchema, toName: z27.string().max(80).optional() }).strict().optional(),
   /** Absent: the agent has no checklist. */
   checklist: PhoneChecklistSummarySchema.optional(),
   /** Started without Ledge (`hook_only`): the phone can neither close nor resume it. */
-  readOnly: z26.literal(true).optional()
+  readOnly: z27.literal(true).optional()
 });
-var B64U2 = z26.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z26.object({
+var B64U2 = z27.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z27.object({
   id: B64U2.max(1366),
   publicKey: B64U2.max(2048),
-  alg: z26.union([z26.literal(-7), z26.literal(-257)]),
+  alg: z27.union([z27.literal(-7), z27.literal(-257)]),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
-  transports: z26.array(z26.string().max(20)).max(8).optional()
+  transports: z27.array(z27.string().max(20)).max(8).optional()
 });
-var AssertionSchema = z26.object({
+var AssertionSchema = z27.object({
   id: B64U2.max(1366),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
   signature: B64U2.max(1024)
 });
-var ConfirmPurposeSchema = z26.enum(["register", "decide", "launch", "close", "act", "pc"]);
+var ConfirmPurposeSchema = z27.enum(["register", "decide", "launch", "close", "act", "pc", "terminal"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z26.object({
-  project: z26.string().max(80),
+var PhoneChatProposalSchema = z27.object({
+  project: z27.string().max(80),
   tool: ToolSchema,
-  prompt: z26.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z26.string().optional(),
-  failed: z26.literal(true).optional()
+  prompt: z27.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z27.string().optional(),
+  failed: z27.literal(true).optional()
 }).strict();
-var PhoneChatRelaySchema = z26.object({
-  id: z26.string().min(1),
-  name: z26.string(),
+var PhoneChatRelaySchema = z27.object({
+  id: z27.string().min(1),
+  name: z27.string(),
   tool: ToolSchema,
-  text: z26.string().max(TOOL_TEXT_MAX),
-  status: z26.enum(["queued", "sent"]).optional(),
-  sentAt: z26.string().datetime().optional(),
-  failed: z26.literal(true).optional(),
+  text: z27.string().max(TOOL_TEXT_MAX),
+  status: z27.enum(["queued", "sent"]).optional(),
+  sentAt: z27.string().datetime().optional(),
+  failed: z27.literal(true).optional(),
   /** With `failed`: why, as the PC's code (never its text). */
-  code: z26.string().max(40).optional()
+  code: z27.string().max(40).optional()
 }).strict();
-var CloseHowSchema = z26.enum(["exit", "killed"]);
-var PhoneChatCloseSchema = z26.object({
-  id: z26.string().min(1),
-  name: z26.string(),
+var CloseHowSchema = z27.enum(["exit", "killed"]);
+var PhoneChatCloseSchema = z27.object({
+  id: z27.string().min(1),
+  name: z27.string(),
   tool: ToolSchema,
   how: CloseHowSchema.optional(),
-  closedAt: z26.string().datetime().optional(),
-  failed: z26.literal(true).optional()
+  closedAt: z27.string().datetime().optional(),
+  failed: z27.literal(true).optional()
 }).strict();
-var PhoneChatTaskSchema = z26.object({
-  to: z26.string().max(80),
-  toName: z26.string().max(80).optional(),
-  title: z26.string().max(200),
-  text: z26.string().max(TOOL_TEXT_MAX).optional(),
-  taskId: z26.string().max(40).optional(),
-  ownerName: z26.string().max(80).optional(),
-  state: z26.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  failed: z26.literal(true).optional()
+var PhoneChatTaskSchema = z27.object({
+  to: z27.string().max(80),
+  toName: z27.string().max(80).optional(),
+  title: z27.string().max(200),
+  text: z27.string().max(TOOL_TEXT_MAX).optional(),
+  taskId: z27.string().max(40).optional(),
+  ownerName: z27.string().max(80).optional(),
+  state: z27.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  failed: z27.literal(true).optional()
 }).strict();
-var PhoneChatActionSchema = z26.object({
-  action: z26.string().min(1).max(40),
-  summary: z26.string().max(300),
+var PhoneChatActionSchema = z27.object({
+  action: z27.string().min(1).max(40),
+  summary: z27.string().max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z26.string().max(TOOL_TEXT_MAX).optional(),
-  detailCut: z26.literal(true).optional(),
+  detail: z27.string().max(TOOL_TEXT_MAX).optional(),
+  detailCut: z27.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z26.string().max(100).optional(),
+  session: z27.string().max(100).optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z26.string().datetime().optional(),
-  code: z26.string().max(40).optional()
+  doneAt: z27.string().datetime().optional(),
+  code: z27.string().max(40).optional()
 }).strict();
-var PhoneTaskSchema = z26.object({
-  id: z26.string().max(40),
-  title: z26.string().max(200),
-  owner: z26.string().max(100),
-  ownerName: z26.string().max(80),
+var PhoneTaskSchema = z27.object({
+  id: z27.string().max(40),
+  title: z27.string().max(200),
+  owner: z27.string().max(100),
+  ownerName: z27.string().max(80),
   /** Who gave it: `ledge` for Ledge's own; a session for a decision it put to the user (owner `ledge`), with its detail (the options). */
-  giver: z26.string().max(100).optional(),
-  giverName: z26.string().max(80).optional(),
-  text: z26.string().max(TOOL_TEXT_MAX).optional(),
-  state: z26.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z26.string().max(TOOL_TEXT_MAX).optional(),
-  cut: z26.literal(true).optional(),
-  at: z26.string(),
-  updatedAt: z26.string(),
-  seen: z26.literal(true).optional()
+  giver: z27.string().max(100).optional(),
+  giverName: z27.string().max(80).optional(),
+  text: z27.string().max(TOOL_TEXT_MAX).optional(),
+  state: z27.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z27.string().max(TOOL_TEXT_MAX).optional(),
+  cut: z27.literal(true).optional(),
+  at: z27.string(),
+  updatedAt: z27.string(),
+  seen: z27.literal(true).optional()
 }).strict();
-var ChatErrorCodeSchema = z26.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z26.object({
+var ChatErrorCodeSchema = z27.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z27.object({
   qid: OperationIdSchema,
-  question: z26.string().max(MESSAGE_MAX),
-  askedAt: z26.string().datetime(),
-  steps: z26.array(PhoneChatStepSchema).max(50),
-  answer: z26.string().max(THREAD_TEXT_MAX).optional(),
-  answeredAt: z26.string().datetime().optional(),
+  question: z27.string().max(MESSAGE_MAX),
+  askedAt: z27.string().datetime(),
+  steps: z27.array(PhoneChatStepSchema).max(50),
+  answer: z27.string().max(THREAD_TEXT_MAX).optional(),
+  answeredAt: z27.string().datetime().optional(),
   error: ChatErrorCodeSchema.optional(),
-  proposals: z26.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  proposals: z27.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
   relay: PhoneChatRelaySchema.optional(),
-  closes: z26.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
-  cut: z26.literal(true).optional(),
-  tasks: z26.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
-  actions: z26.array(PhoneChatActionSchema).min(1).max(MAX_PROPOSALS).optional(),
-  ignoredAt: z26.string().datetime().optional(),
-  attachments: z26.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
+  closes: z27.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
+  cut: z27.literal(true).optional(),
+  tasks: z27.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
+  actions: z27.array(PhoneChatActionSchema).min(1).max(MAX_PROPOSALS).optional(),
+  ignoredAt: z27.string().datetime().optional(),
+  attachments: z27.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
 }).strict();
-var sessionId = z26.string().min(1).max(100);
-var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z26.string().min(1).max(64) });
-var CardRowsSchema = z26.array(z26.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 sessionId = z27.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z27.string().min(1).max(64) });
+var CardRowsSchema = z27.array(z27.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
 var pcOp = { op: OperationIdSchema, assertion: AssertionSchema.optional() };
-var PcActionSchema = z26.enum(["update", "restart"]);
-var PhoneClientMessageSchema = z26.discriminatedUnion("type", [
-  z26.object({ type: z26.literal("snapshot.request") }),
-  z26.object({ type: z26.literal("session.thread"), id: sessionId }),
+var PcActionSchema = z27.enum(["update", "restart"]);
+var TerminalIdSchema = z27.string().regex(/^t_[A-Za-z0-9_-]{8,40}$/);
+var TERM_INPUT_MAX = 4096;
+var TERM_SCREEN_MAX = 65536;
+var TERM_OUTPUT_MAX = 32768;
+var TermDimSchema = z27.number().int().min(1).max(1e4);
+var TermReleaseWhySchema = z27.enum(["asked", "pc", "idle", "expired", "background", "link"]);
+var TermExitWhySchema = z27.enum(["ended", "gone", "closed", "superseded", "failed"]);
+var PhoneClientMessageSchema = z27.discriminatedUnion("type", [
+  z27.object({ type: z27.literal("snapshot.request") }),
+  z27.object({ type: z27.literal("session.thread"), id: sessionId }),
   /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
-  z26.object({ type: z26.literal("session.pending"), id: sessionId }),
+  z27.object({ type: z27.literal("session.pending"), id: sessionId }),
   /** The session whose terminal the phone shows; null when it shows none. */
-  z26.object({ type: z26.literal("session.watch"), id: sessionId.nullable() }),
-  z26.object({ type: z26.literal("session.read"), id: sessionId, at: z26.string().datetime() }),
+  z27.object({ type: z27.literal("session.watch"), id: sessionId.nullable() }),
+  z27.object({ type: z27.literal("session.read"), id: sessionId, at: z27.string().datetime() }),
   /**
    * Asks for a challenge. One object for every purpose: the gateway refuses a `decide` without `id` and `expect`. A `close`
    * or `act` names a turn of the chat (`qid`) or a session (`id`, for `session.close` and `session.resume`).
    */
-  z26.object({
-    type: z26.literal("confirm.prepare"),
+  z27.object({
+    type: z27.literal("confirm.prepare"),
     purpose: ConfirmPurposeSchema,
     id: sessionId.optional(),
     expect: PhoneExpectSchema.optional(),
     qid: OperationIdSchema.optional(),
     /** A `pc` challenge: what it is for, and for an update the version it covers. */
     action: PcActionSchema.optional(),
-    version: z26.string().regex(SEMVER).optional()
+    version: z27.string().regex(SEMVER).optional()
   }),
-  z26.object({ type: z26.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z26.object({
-    type: z26.literal("session.decide"),
+  z27.object({ type: z27.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z27.object({
+    type: z27.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z26.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z27.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()
   }),
-  z26.object({
-    type: z26.literal("session.reply"),
+  z27.object({
+    type: z27.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z26.string().max(MESSAGE_MAX),
-    attachments: z26.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+    text: z27.string().max(MESSAGE_MAX),
+    attachments: z27.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`. */
-  z26.object({
-    type: z26.literal("session.answer"),
+  z27.object({
+    type: z27.literal("session.answer"),
     op: OperationIdSchema,
     id: sessionId,
-    requestId: z26.string().min(1).max(200),
-    answers: z26.array(z26.object({ id: z26.string().max(200), selected: z26.array(z26.string().max(2e3)).max(100), text: z26.string().max(2e4).optional() })).max(50),
-    cancel: z26.literal(true).optional(),
+    requestId: z27.string().min(1).max(200),
+    answers: z27.array(z27.object({ id: z27.string().max(200), selected: z27.array(z27.string().max(2e3)).max(100), text: z27.string().max(2e4).optional() })).max(50),
+    cancel: z27.literal(true).optional(),
     expect: PhoneExpectSchema
   }),
-  z26.object({ type: z26.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  z27.object({ type: z27.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
   /** Ends a live session as `/exit` would, killed as a last resort; answered with its `how`. Passkey, purpose `close`, over the session. */
-  z26.object({ type: z26.literal("session.close"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
+  z27.object({ type: z27.literal("session.close"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
   /** Starts an ended session again on its conversation. Passkey, purpose `act`, over the session. */
-  z26.object({ type: z26.literal("session.resume"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
+  z27.object({ type: z27.literal("session.resume"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
   /** Changes a live session's model and effort, `null` for the agent's own default; answered by `operation.result` and, when refused, `session.model.failed`. */
-  z26.object({ type: z26.literal("session.model"), op: OperationIdSchema, id: sessionId, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  z27.object({ type: z27.literal("session.model"), op: OperationIdSchema, id: sessionId, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  /** One message to several sessions (ids); answered by `operation.result` with `sent` and `refused`. */
+  z27.object({ type: z27.literal("session.broadcast"), op: OperationIdSchema, sessions: z27.array(sessionId).min(1).max(BROADCAST_SESSIONS_MAX), text: z27.string().trim().min(1).max(MESSAGE_MAX) }).strict(),
   /** The models an agent offers on the PC. */
-  z26.object({ type: z26.literal("models.list"), tool: ToolSchema }),
+  z27.object({ type: z27.literal("models.list"), tool: ToolSchema }),
+  /** The slash commands of a session's agent, for the « / » list of its field. */
+  z27.object({ type: z27.literal("session.commands"), id: sessionId }),
   /** The phone drops its passkey from the daemon. */
-  z26.object({ type: z26.literal("device.forget"), op: OperationIdSchema }),
+  z27.object({ type: z27.literal("device.forget"), op: OperationIdSchema }),
   /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z26.object({ type: z26.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
-  z26.object({ type: z26.literal("push.unsubscribe"), op: OperationIdSchema }),
+  z27.object({ type: z27.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z27.object({ type: z27.literal("push.unsubscribe"), op: OperationIdSchema }),
   /** The phone's own chat with Ledge. */
-  z26.object({ type: z26.literal("chat.ask"), qid: OperationIdSchema, text: z26.string().trim().max(MESSAGE_MAX), attachments: z26.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
-  z26.object({ type: z26.literal("chat.cancel"), qid: OperationIdSchema }),
-  z26.object({ type: z26.literal("chat.reset") }),
-  z26.object({ type: z26.literal("chat.history") }),
+  z27.object({ type: z27.literal("chat.ask"), qid: OperationIdSchema, text: z27.string().trim().max(MESSAGE_MAX), attachments: z27.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
+  z27.object({ type: z27.literal("chat.cancel"), qid: OperationIdSchema }),
+  z27.object({ type: z27.literal("chat.reset") }),
+  z27.object({ type: z27.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: z26.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
+  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z27.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
   AttachmentGetSchema.pick({ type: true, requestId: true, attachment: true, preview: true }),
-  z26.object({ type: z26.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z27.object({ type: z27.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
   /** Takes the card's queued instruction back out of the queue, as the local `session.relay.cancel`. */
-  z26.object({ type: z26.literal("chat.relay.cancel"), op: OperationIdSchema, qid: OperationIdSchema }),
-  z26.object({ type: z26.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
-  z26.object({ type: z26.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z27.object({ type: z27.literal("chat.relay.cancel"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z27.object({ type: z27.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z27.object({ type: z27.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
   /** A row of the turn's task card: given by Ledge. */
-  z26.object({ type: z26.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z26.number().int().min(0).max(MAX_PROPOSALS - 1) }),
+  z27.object({ type: z27.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z27.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. */
-  z26.object({
-    type: z26.literal("chat.act"),
+  z27.object({
+    type: z27.literal("chat.act"),
     op: OperationIdSchema,
     qid: OperationIdSchema,
     rows: CardRowsSchema.optional(),
-    confirmed: z26.literal(true).optional(),
+    confirmed: z27.literal(true).optional(),
     assertion: AssertionSchema.optional(),
     /** « Refuser », as the local `chat.act`: no passkey, no confirmation. */
-    deny: z26.literal(true).optional()
+    deny: z27.literal(true).optional()
   }),
   /** « Ignorer » the turn's cards, or `undo` (« Revoir »), as the local `chat.ignore`. */
-  z26.object({ type: z26.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z26.literal(true).optional() }),
+  z27.object({ type: z27.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z27.literal(true).optional() }),
   /** Puts a closed task Ledge gave away from « À traiter ». */
-  z26.object({ type: z26.literal("task.seen"), op: OperationIdSchema, task: z26.string().min(1).max(40) }),
+  z27.object({ type: z27.literal("task.seen"), op: OperationIdSchema, task: z27.string().min(1).max(40) }),
+  /** Streams a session's pane, read-only; answered by `term.opened` or `operation.result` (rejected). */
+  z27.object({ type: z27.literal("term.open"), op: OperationIdSchema, id: sessionId }),
+  /** « Prendre la main »: passkey, purpose `terminal`, over the session; answered by `term.held` or `operation.result` (rejected). */
+  z27.object({ type: z27.literal("term.hold"), op: OperationIdSchema, tid: TerminalIdSchema, assertion: AssertionSchema.optional() }),
+  /** Keys to type, as xterm produced them; `n` counts from 0 for the terminal, so a duplicate is dropped and a gap seen. Refused unless held. */
+  z27.object({ type: z27.literal("term.input"), tid: TerminalIdSchema, n: z27.number().int().nonnegative(), data: z27.string().min(1).max(TERM_INPUT_MAX) }),
+  /** « Rendre la main »: back to read-only. */
+  z27.object({ type: z27.literal("term.release"), tid: TerminalIdSchema }),
+  /** The phone saw a gap in `seq`: a fresh `term.opened`, please. */
+  z27.object({ type: z27.literal("term.resync"), tid: TerminalIdSchema }),
+  z27.object({ type: z27.literal("term.close"), tid: TerminalIdSchema }),
   /** Whether the phone's app is in front: a device that is visible gets no push. */
-  z26.object({ type: z26.literal("presence"), visible: z26.boolean() }),
+  z27.object({ type: z27.literal("presence"), visible: z27.boolean() }),
   /** Installs `version` on the PC, then restarts its daemon; the phone asks for its own build's version. Passkey, purpose `pc`. */
-  z26.object({ type: z26.literal("daemon.update"), ...pcOp, version: z26.string().regex(SEMVER) }).strict(),
+  z27.object({ type: z27.literal("daemon.update"), ...pcOp, version: z27.string().regex(SEMVER) }).strict(),
   /** Restarts the PC's daemon without installing anything. Passkey, purpose `pc`. */
-  z26.object({ type: z26.literal("daemon.restart"), ...pcOp }).strict()
+  z27.object({ type: z27.literal("daemon.restart"), ...pcOp }).strict()
 ]);
-var PhoneModelChoiceSchema = z26.object({
+var PhoneModelChoiceSchema = z27.object({
   id: ModelChoiceSchema.shape.id.max(120),
-  label: z26.string().max(80),
-  description: z26.string().max(200).optional(),
-  efforts: z26.array(EffortSchema).max(8).optional(),
+  label: z27.string().max(80),
+  description: z27.string().max(200).optional(),
+  efforts: z27.array(EffortSchema).max(8).optional(),
   defaultEffort: EffortSchema.optional(),
-  isDefault: z26.boolean().optional()
+  isDefault: z27.boolean().optional()
 }).strict();
-var PhoneServerMessageSchema = z26.discriminatedUnion("type", [
-  z26.object({ type: z26.literal("snapshot"), protocol: z26.literal(PHONE_PROTOCOL), sessions: z26.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z26.object({
-    version: z26.string(),
-    name: z26.string().max(40),
-    boot: z26.string().uuid().optional(),
+var PHONE_COMMANDS_MAX = 300;
+var PhoneSlashCommandSchema = SlashCommandSchema.extend({ description: z27.string().max(200).optional() }).strict();
+var PhoneServerMessageSchema = z27.discriminatedUnion("type", [
+  z27.object({ type: z27.literal("snapshot"), protocol: z27.literal(PHONE_PROTOCOL), sessions: z27.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z27.object({
+    version: z27.string(),
+    name: z27.string().max(40),
+    boot: z27.string().uuid().optional(),
     /** The daemon takes `session.model`. */
-    models: z26.literal(true).optional(),
+    models: z27.literal(true).optional(),
     /** The daemon sends `session.checklist` and a session's `checklist` summary. */
-    checklist: z26.literal(true).optional(),
+    checklist: z27.literal(true).optional(),
     /** `update`: the daemon can install a version and restart (npm, systemd); `restart`: it can restart (systemd). */
-    update: z26.literal(true).optional(),
-    restart: z26.literal(true).optional(),
+    update: z27.literal(true).optional(),
+    restart: z27.literal(true).optional(),
     /** The daemon takes `session.close` and `session.resume`. */
-    sessionClose: z26.literal(true).optional()
-  }), device: z26.object({ confirm: z26.boolean(), push: z26.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z26.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
-  z26.object({ type: z26.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z26.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z26.number().int().positive() }),
-  z26.object({ type: z26.literal("session.updated"), session: PhoneSessionSchema }),
-  z26.object({ type: z26.literal("session.removed"), id: z26.string() }),
+    sessionClose: z27.literal(true).optional(),
+    /** The daemon streams a session's terminal (`term.open`). */
+    terminal: z27.literal(true).optional(),
+    /** The PC lets a phone type into a terminal (`term.hold`): its setting is on. */
+    terminalInput: z27.literal(true).optional(),
+    /** The daemon answers `session.commands`. */
+    commands: z27.literal(true).optional(),
+    /** The daemon takes `session.broadcast` (« Écrire au groupe »). */
+    broadcast: z27.literal(true).optional()
+  }), device: z27.object({ confirm: z27.boolean(), push: z27.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z27.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  z27.object({ type: z27.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z27.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z27.number().int().positive() }),
+  z27.object({ type: z27.literal("session.updated"), session: PhoneSessionSchema }),
+  z27.object({ type: z27.literal("session.removed"), id: z27.string() }),
   /** A session's checklist, sent to the phone that watches it; `null`: it has none (any more). */
-  z26.object({ type: z26.literal("session.checklist"), id: z26.string(), checklist: PhoneChecklistSchema.nullable() }),
+  z27.object({ type: z27.literal("session.checklist"), id: z27.string(), checklist: PhoneChecklistSchema.nullable() }),
   /** `pending.cut` is set when even this body was shortened. */
-  z26.object({ type: z26.literal("session.pending"), id: z26.string(), pending: PhonePendingSchema }),
-  z26.object({ type: z26.literal("session.preview"), id: z26.string(), lines: z26.array(z26.string()) }),
+  z27.object({ type: z27.literal("session.pending"), id: z27.string(), pending: PhonePendingSchema }),
+  z27.object({ type: z27.literal("session.preview"), id: z27.string(), lines: z27.array(z27.string()) }),
   /** `cut`: the ids of the items shortened; `more`: older items were left out. */
-  z26.object({ type: z26.literal("session.thread"), id: z26.string(), items: z26.array(ThreadItemSchema), cut: z26.array(z26.string()), more: z26.boolean() }),
-  z26.object({ type: z26.literal("session.thread.item"), id: z26.string(), item: ThreadItemSchema, cut: z26.literal(true).optional() }),
-  z26.object({
-    type: z26.literal("operation.result"),
+  z27.object({ type: z27.literal("session.thread"), id: z27.string(), items: z27.array(ThreadItemSchema), cut: z27.array(z27.string()), more: z27.boolean() }),
+  z27.object({ type: z27.literal("session.thread.item"), id: z27.string(), item: ThreadItemSchema, cut: z27.literal(true).optional() }),
+  z27.object({
+    type: z27.literal("operation.result"),
     op: OperationIdSchema,
     status: OperationStatusSchema,
     reason: OperationReasonSchema.optional(),
     /** How an applied `session.close` ended the agent: `killed` when it had to be forced. */
-    how: CloseHowSchema.optional()
+    how: CloseHowSchema.optional(),
+    /** An applied `session.broadcast`: the names that got it and those that did not. */
+    sent: z27.array(z27.string().max(100)).max(BROADCAST_SESSIONS_MAX).optional(),
+    refused: z27.array(z27.object({ name: z27.string().max(100), reason: z27.string().max(200) })).max(BROADCAST_SESSIONS_MAX).optional()
   }),
   /** The models an agent offers; `error`: it could not be asked, `models` is then what Ledge knows without it. */
-  z26.object({ type: z26.literal("models.listing"), tool: ToolSchema, models: z26.array(PhoneModelChoiceSchema).max(40), error: z26.literal(true).optional() }),
+  z27.object({ type: z27.literal("models.listing"), tool: ToolSchema, models: z27.array(PhoneModelChoiceSchema).max(40), error: z27.literal(true).optional() }),
   /** A model change that was accepted and then failed (the agent could not restart). */
-  z26.object({ type: z26.literal("session.model.failed"), id: z26.string(), reason: ModelRefusalSchema }),
-  z26.object({ type: z26.literal("chat.history"), turns: z26.array(PhoneChatTurnSchema).max(50) }),
-  z26.object({ type: z26.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  z27.object({ type: z27.literal("session.model.failed"), id: z27.string(), reason: ModelRefusalSchema }),
+  /** A session's slash commands; `error`: they could not be read (the agent is not listed, or did not answer in time): a command typed by hand still goes. */
+  z27.object({ type: z27.literal("session.commands.listing"), id: z27.string(), commands: z27.array(PhoneSlashCommandSchema).max(PHONE_COMMANDS_MAX), error: z27.literal(true).optional() }),
+  z27.object({ type: z27.literal("chat.history"), turns: z27.array(PhoneChatTurnSchema).max(50) }),
+  z27.object({ type: z27.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
   /** The whole text so far, not an increment. */
-  z26.object({ type: z26.literal("chat.delta"), qid: OperationIdSchema, text: z26.string().max(THREAD_TEXT_MAX) }),
-  z26.object({ type: z26.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
-  z26.object({ type: z26.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
+  z27.object({ type: z27.literal("chat.delta"), qid: OperationIdSchema, text: z27.string().max(THREAD_TEXT_MAX) }),
+  z27.object({ type: z27.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z27.object({ type: z27.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
   /** The daemon updating or restarting itself, whoever asked: npm runs, then the service restarts (the link drops right after). */
-  z26.object({ type: z26.literal("daemon.progress"), version: z26.string().max(40), step: z26.enum(["installing", "restarting"]) }),
+  z27.object({ type: z27.literal("daemon.progress"), version: z27.string().max(40), step: z27.enum(["installing", "restarting"]) }),
   /** Nothing was changed. Never npm's output nor a command: both hold the PC's paths. */
-  z26.object({ type: z26.literal("daemon.failed"), version: z26.string().max(40), reason: UpdateFailureSchema }),
+  z27.object({ type: z27.literal("daemon.failed"), version: z27.string().max(40), reason: UpdateFailureSchema }),
   /** The tasks Ledge gave, open or closed lately, after each snapshot; then each change. */
-  z26.object({ type: z26.literal("tasks"), tasks: z26.array(PhoneTaskSchema).max(200) }),
-  z26.object({ type: z26.literal("task.updated"), task: PhoneTaskSchema }),
+  z27.object({ type: z27.literal("tasks"), tasks: z27.array(PhoneTaskSchema).max(200) }),
+  z27.object({ type: z27.literal("task.updated"), task: PhoneTaskSchema }),
   AttachmentStoredSchema,
   AttachmentDataSchema,
   AttachmentErrorSchema,
+  /** A terminal's first screen (also the answer to `term.resync`, then without `op`): the pane's size, the cursor, and the `seq` the next output takes. */
+  z27.object({
+    type: z27.literal("term.opened"),
+    op: OperationIdSchema.optional(),
+    tid: TerminalIdSchema,
+    id: z27.string(),
+    cols: TermDimSchema,
+    rows: TermDimSchema,
+    screen: z27.string().max(TERM_SCREEN_MAX),
+    cursor: z27.object({ x: z27.number().int().nonnegative(), y: z27.number().int().nonnegative() }),
+    seq: z27.number().int().nonnegative(),
+    /** Read-only for good: a subagent's page shows its parent's pane. */
+    readOnly: z27.literal(true).optional()
+  }),
+  /** What the pane printed since the last one; `seq` + 1 each time. */
+  z27.object({ type: z27.literal("term.output"), tid: TerminalIdSchema, seq: z27.number().int().nonnegative(), data: z27.string().min(1).max(TERM_OUTPUT_MAX) }),
+  z27.object({ type: z27.literal("term.size"), tid: TerminalIdSchema, cols: TermDimSchema, rows: TermDimSchema }),
+  /** The phone holds the hand until `until`, pushed back by each key (5 min), never past 30 min from the hold. */
+  z27.object({ type: z27.literal("term.held"), tid: TerminalIdSchema, until: z27.string().datetime() }),
+  z27.object({ type: z27.literal("term.released"), tid: TerminalIdSchema, why: TermReleaseWhySchema }),
+  z27.object({ type: z27.literal("term.exit"), tid: TerminalIdSchema, why: TermExitWhySchema }),
   /** Never carries free text. */
-  z26.object({ type: z26.literal("error"), code: z26.enum(["invalid", "unknown_session", "too_large"]), request: z26.string().max(40).optional() })
+  z27.object({ type: z27.literal("error"), code: z27.enum(["invalid", "unknown_session", "too_large"]), request: z27.string().max(40).optional() })
 ]);
 
 // src/imageInfo.ts