@paradow/ledge 0.36.0 → 0.38.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 z24 } from "zod";
 
 // ../protocol/src/repos.ts
 import { z as z15 } from "zod";
@@ -742,437 +746,724 @@ 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()
+});
+var HumanQuestionAnswerSchema = z18.discriminatedUnion("kind", [
+  z18.object({ kind: z18.literal("option"), id: z18.string() }),
+  z18.object({ kind: z18.literal("words"), text: z18.string() })
+]);
+var HumanQuestionSchema = z18.object({
+  id: z18.string(),
+  question: z18.string(),
+  options: z18.array(z18.object({ id: z18.string(), label: z18.string(), recommended: z18.boolean() })),
+  answer: HumanQuestionAnswerSchema.nullable()
+});
+var TeamProposalSchema = z18.object({
+  /** `existing`: the goal goes to a team that exists; `launch`: a new rig is launched, with what that does in `launch`. */
+  kind: z18.enum(["existing", "launch"]),
+  rig: z18.string(),
+  running: z18.boolean().nullable(),
+  folder: z18.string().nullable(),
+  seats: z18.array(z18.object({ seat: z18.string(), name: z18.string().nullable(), role: z18.string().nullable(), note: z18.string().nullable() })),
+  reason: z18.string().nullable(),
+  /** For a launch, before any yes: agents, runtimes, `rig up --plan`'s summary, what it writes in the folder, the seats' permissions. */
+  launch: z18.object({ agents: z18.number().int().nullable(), runtimes: z18.array(z18.string()), plan: z18.string().nullable(), writes: z18.array(z18.string()), permissions: z18.string().nullable() }).nullable()
+});
+var HumanAskSchema = z18.object({
+  id: z18.string(),
+  kind: z18.enum(["decision", "update", "parked"]),
+  alert: z18.boolean(),
+  priority: z18.enum(["routine", "urgent", "critical"]),
+  from: z18.object({ seat: z18.string(), rig: z18.string().nullable(), role: z18.string().nullable() }),
+  summary: z18.string(),
+  body: z18.string(),
+  bodyTruncated: z18.boolean(),
+  detail: z18.string().nullable(),
+  /** The detail was cut (on the phone, to fit its message): its end, which may decide, is not shown. */
+  detailTruncated: z18.literal(true).optional(),
+  evidenceRef: z18.string().nullable(),
+  questions: z18.array(HumanQuestionSchema),
+  createdAt: z18.string(),
+  updatedAt: z18.string(),
+  /** Max's proposal for this goal (the ask's `ledge-goal:<id>` tag), and the team it names when its block reads. */
+  goalId: z18.string().optional(),
+  team: TeamProposalSchema.optional()
+});
+var HumanChannelSchema = z18.object({
+  /** `no_default`: several people are registered and none is the default, so whose asks they are is unknown (nothing is shown). */
+  state: z18.enum(["ready", "no_person", "no_default", "openrig_stopped", "not_installed", "unreachable"]),
+  person: z18.object({ address: z18.string(), name: z18.string() }).nullable(),
+  /** Slack still posts the person's asks too. */
+  slack: z18.boolean(),
+  message: z18.string().optional()
+});
+var OpenRigAsksSchema = z18.object({ type: z18.literal("openrig.asks"), requestId: z18.string().min(1).max(100), machineId: z18.string().optional() });
+var OpenRigAsksChangedSchema = z18.object({
+  type: z18.literal("openrig.asksChanged"),
+  requestId: z18.string().optional(),
+  machineId: z18.string().optional(),
+  channel: HumanChannelSchema.optional(),
+  asks: z18.array(HumanAskSchema),
+  truncated: z18.boolean().optional(),
+  /** A read failed (OpenRig unreachable, a row or a source not read): the asks known before are kept; none missing is settled. */
+  partial: z18.boolean().optional(),
+  error: z18.enum(["offline", "outdated"]).optional()
+});
+var HumanAnswerSchema = z18.discriminatedUnion("kind", [
+  z18.object({ kind: z18.literal("choice"), questionId: z18.string().min(1).max(200), optionId: z18.string().min(1).max(200) }),
+  z18.object({ kind: z18.literal("words"), text: z18.string().trim().min(1).max(8e3) }),
+  z18.object({ kind: z18.literal("seen") }),
+  z18.object({ kind: z18.literal("resolve"), text: z18.string().trim().min(1).max(8e3) })
+]);
+var OpenRigAnswerSchema = z18.object({
+  type: z18.literal("openrig.answer"),
+  requestId: z18.string().min(1).max(100),
+  machineId: z18.string().optional(),
+  qitemId: z18.string().min(1).max(200),
+  answer: HumanAnswerSchema
+});
+var HumanAnswerErrorSchema = z18.enum(["not_found", "closed", "refused", "not_closed", "unreachable", "openrig_stopped", "uncertain", "offline", "outdated"]);
+var OpenRigAnsweredSchema = z18.object({
+  type: z18.literal("openrig.answered"),
+  requestId: z18.string(),
+  machineId: z18.string().optional(),
+  qitemId: z18.string(),
+  ok: z18.boolean(),
+  outcome: z18.enum(["recorded", "answered", "already"]).optional(),
+  remaining: z18.array(z18.string()).optional(),
+  replyId: z18.string().optional(),
+  error: HumanAnswerErrorSchema.optional(),
+  message: z18.string().optional()
+});
+var GoalErrorSchema = z18.enum(["no_operator", "openrig_stopped", "unreachable", "uncertain", "refused", "offline", "outdated"]);
+var GoalIdSchema = z18.string().regex(/^[A-Za-z0-9-]{8,64}$/, "not a goal id");
+var GoalSchema = z18.object({
+  goalId: z18.string(),
+  qitemId: z18.string(),
+  text: z18.string(),
+  folder: z18.string().nullable(),
+  sentAt: z18.string(),
+  to: z18.string(),
+  state: z18.enum(["sent", "taken", "asking", "proposed", "running", "done", "closed"]),
+  /** The latest proposal: after « Changer d'équipe » Max makes a new one. */
+  proposal: z18.object({
+    askId: z18.string(),
+    team: TeamProposalSchema.nullable(),
+    text: z18.string(),
+    answer: HumanQuestionAnswerSchema.nullable(),
+    answeredAt: z18.string().nullable()
+  }).nullable(),
+  /** Max's question still open (no folder, no fitting team): it waits in « À toi ». */
+  question: z18.object({ askId: z18.string(), text: z18.string() }).nullable(),
+  trail: z18.array(z18.object({
+    at: z18.string(),
+    kind: z18.enum(["sent", "taken", "note", "handed", "closed"]),
+    seat: z18.string(),
+    to: z18.string().optional(),
+    text: z18.string().optional(),
+    qitemId: z18.string()
+  })),
+  current: z18.object({ qitemId: z18.string(), seat: z18.string(), state: z18.string() }).nullable()
+});
+var OpenRigGoalSendSchema = z18.object({
+  type: z18.literal("openrig.goal.send"),
+  requestId: z18.string().min(1).max(100),
+  machineId: z18.string().optional(),
+  goalId: GoalIdSchema,
+  text: z18.string().trim().min(1).max(8e3),
+  folder: z18.string().min(1).max(4096).optional()
+});
+var OpenRigGoalSentSchema = z18.object({
+  type: z18.literal("openrig.goal.sent"),
+  requestId: z18.string(),
+  machineId: z18.string().optional(),
+  goalId: z18.string(),
+  ok: z18.boolean(),
+  qitemId: z18.string().optional(),
+  error: GoalErrorSchema.optional(),
+  message: z18.string().optional()
+});
+var OpenRigGoalsSchema = z18.object({ type: z18.literal("openrig.goals"), requestId: z18.string().min(1).max(100), machineId: z18.string().optional() });
+var OpenRigGoalsChangedSchema = z18.object({
+  type: z18.literal("openrig.goalsChanged"),
+  requestId: z18.string().optional(),
+  machineId: z18.string().optional(),
+  goals: z18.array(GoalSchema),
+  partial: z18.boolean().optional(),
+  error: z18.enum(["offline", "outdated"]).optional()
+});
+var OpenRigGoalReplySchema = z18.object({
+  type: z18.literal("openrig.goal.reply"),
+  requestId: z18.string().min(1).max(100),
+  machineId: z18.string().optional(),
+  goalId: GoalIdSchema,
+  replyId: GoalIdSchema,
+  text: z18.string().trim().min(1).max(8e3)
+});
+var OpenRigGoalRepliedSchema = z18.object({
+  type: z18.literal("openrig.goal.replied"),
+  requestId: z18.string(),
+  machineId: z18.string().optional(),
+  goalId: z18.string(),
+  /** The reply's own id, always: sending it again after `uncertain` reuses it, and never wakes Max twice. */
+  replyId: z18.string(),
+  ok: z18.boolean(),
+  qitemId: z18.string().optional(),
+  error: GoalErrorSchema.optional(),
+  message: z18.string().optional()
+});
+
+// ../protocol/src/rigMessages.ts
+import { z as z19 } from "zod";
+var QitemIdSchema = z19.string().regex(/^qitem-[A-Za-z0-9-]{1,120}$/, "not a qitem");
+var QITEM = "qitem-[A-Za-z0-9-]+";
+var RigKindSchema = z19.enum(["message", "handoff", "unblocked", "openrig", "unreadable"]);
+var RigInfoSchema = z19.object({
+  kind: RigKindSchema,
+  /** The envelope's From, as written (`pilot-lead@ledge-dev-2`, `daemon@kernel`, `ledge@external`, `<unknown sender>`).
+   *  On the seat's own `sent`: absent (it is the seat). The item's `peer` is the Ledge session of that seat, when known. */
+  from: z19.string().optional(),
+  /** The envelope's To, as written (a seat, a list `a, b`, or `broadcast to <rig> (n seats)`); on an outgoing item, the
+   *  destination the command named. */
+  to: z19.string().optional(),
+  /** The envelope's `Sent:` stamp as an ISO time (OpenRig gives no year: the year of receipt, or the year before when
+   *  that would put it in the future). Absent when the envelope has no `Sent:` line. */
+  sentAt: z19.string().datetime().optional(),
+  /** The sender's generation (8 hex), when the stamp carries one. */
+  gen: z19.string().optional(),
+  /** The row the item is about. `handoff`: the row handed (outgoing: the new row, when the command's output names it);
+   *  `unblocked`: the parked row now pending; `openrig`: the row it names (a stuck sweep: the stalled row). */
+  qitem: QitemIdSchema.optional(),
+  /** `handoff`: the row's summary as OpenRig carried it (one line, at most 120 characters, `…` when cut). */
+  summary: z19.string().optional(),
+  /** `unblocked`: the row whose closing unblocked it. */
+  blocker: QitemIdSchema.optional(),
+  /** `openrig`: the recovery row OpenRig opened for it (a stuck sweep comes as a handoff of a `qitem-recovery-…` row). */
+  recovery: QitemIdSchema.optional(),
+  /** `openrig`: `stalled` a stuck sweep (a seat that does not move: amber), `custody` a custody check; else absent. */
+  alert: z19.enum(["stalled", "custody"]).optional(),
+  /** `openrig` with an alert: how long, in minutes, as OpenRig said. */
+  minutes: z19.number().int().nonnegative().optional(),
+  /** The seat's own command (an outgoing `sent` or `handoff`): the Bash command, as run. */
+  command: z19.string().optional(),
+  /** OpenRig said the delivery may repeat (`Recovered queue notification`). */
+  recovered: z19.literal(true).optional(),
+  /** Received that many times (2 or more): the same block came again, and this item stands for all of them. */
+  count: z19.number().int().min(2).optional(),
+  /** Blocks pasted together in one prompt: the prompt's id, this block's place and how many there were. The front shows
+   *  one raw for the packet, the raws of its items joined. */
+  packet: z19.object({ id: z19.string().min(1), index: z19.number().int().nonnegative(), count: z19.number().int().min(2) }).optional(),
+  /** The block exactly as received (every delivery, separated by a blank line, when `count` is set); outgoing: the command
+   *  and what it printed. Always there. */
+  raw: z19.string()
+});
+var HANDOFF = new RegExp(`^Queue handoff: (${QITEM}) - check your queue\\.(?: Summary: (.*))?$`);
+var BLOCKER = new RegExp(`^Blocker (${QITEM}) resolved; parked qitem (${QITEM}) is pending\\.`);
+var STALLED = new RegExp(`^Stuck sweep: \\S+ on (${QITEM}) \\((\\d+) min\\)`);
+var CUSTODY = new RegExp(`^Custody not checked\\b.*?(?:for |of )(${QITEM}).*?\\((\\d+) min\\)`);
+var RigRowSchema = z19.object({
+  id: QitemIdSchema,
+  state: z19.string().min(1),
+  summary: z19.string().optional(),
+  /** Who made it and who holds it (seats). */
+  from: z19.string(),
+  to: z19.string(),
+  /** `handed-off`: the seat it went to. */
+  handedOffTo: z19.string().optional(),
+  /** `blocked`: the row it waits on. */
+  blockedOn: z19.string().optional(),
+  createdAt: z19.string(),
+  claimedAt: z19.string().optional(),
+  updatedAt: z19.string(),
+  /** When Ledge read it. */
+  at: z19.string()
+});
+var OpenRigRowSchema = z19.object({ type: z19.literal("openrig.row"), requestId: z19.string().min(1).max(100), qitem: QitemIdSchema, machineId: z19.string().optional() });
+var OpenRigRowStateSchema = z19.object({
+  type: z19.literal("openrig.rowState"),
+  requestId: z19.string(),
+  machineId: z19.string().optional(),
+  qitem: z19.string(),
+  row: RigRowSchema.optional(),
+  error: z19.string().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 z20 } from "zod";
+var RoleUnknownWhySchema = z20.enum(["resolved_at_launch", "not_exposed", "unreadable", "ambiguous", "not_found", "missing_from_guidance"]);
+var RoleFromSchema = z20.enum(["import", "defaults", "profile", "rig", "pod", "member", "launch", "openrig", "plugin", "seat"]);
+var OriginSchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("here"), key: z20.string().optional() }),
+  z20.object({ kind: z20.literal("inherited"), from: RoleFromSchema, ref: z20.string().optional(), key: z20.string().optional(), path: z20.string().optional() }),
+  z20.object({ kind: z20.literal("absent") }),
+  z20.object({ kind: z20.literal("unknown"), why: RoleUnknownWhySchema, detail: z20.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 = z20.object({ value: z20.string().nullable(), origin: OriginSchema });
+var RoleResourceCategorySchema = z20.enum(["skill", "guidance", "plugin", "subagent", "runtime_resource"]);
+var RoleResourceSchema = z20.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: z20.string(),
+  path: z20.string().optional(),
+  absolutePath: z20.string().optional(),
+  runtime: z20.string().optional(),
+  type: z20.string().optional(),
+  target: z20.string().optional(),
+  plugin: z20.object({ version: z20.string().optional(), skills: z20.array(z20.string()), hooks: z20.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 = z20.object({ declared: z20.boolean(), key: z20.string(), items: z20.array(RoleResourceSchema) });
+var StartupLayerSchema = z20.enum(["agent", "profile", "culture", "rig", "pod", "member", "openrig", "seat", "unknown"]);
+var StartupEntrySchema = z20.object({
+  kind: z20.enum(["file", "action"]),
+  path: z20.string().optional(),
+  absolutePath: z20.string().optional(),
+  size: z20.number().int().min(0).optional(),
+  value: z20.string().optional(),
+  builtin: z20.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: z20.boolean(),
+  delivery: z20.string(),
+  into: z20.string().optional(),
+  delivered: z20.boolean().optional(),
+  required: z20.boolean().optional(),
+  orientation: z20.string().optional(),
+  appliesOn: z20.array(z20.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 = z20.object({ kind: z20.enum(["missing", "invalid"]), message: z20.string(), line: z20.number().int().optional(), col: z20.number().int().optional() });
+var RoleSummarySchema = z20.object({
+  id: z20.string(),
+  name: z20.string(),
+  version: z20.string().optional(),
+  description: z20.string().optional(),
+  source: z20.enum(["builtin", "user"]),
+  path: z20.string(),
+  runtime: z20.string().optional(),
+  importOnly: z20.boolean(),
+  seats: z20.number().int().min(0),
+  running: z20.number().int().min(0),
+  skills: z20.array(z20.string()),
+  startupFiles: z20.array(z20.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: z20.array(z20.object({ rig: z20.string(), logicalId: z20.string(), session: z20.string().optional() })),
+  error: z20.enum(["missing", "invalid"]).optional()
+});
+var RoleImportSchema = z20.object({
+  ref: z20.string(),
+  key: z20.string(),
+  name: z20.string().optional(),
+  path: z20.string().optional(),
+  version: z20.string().optional(),
+  resolved: z20.boolean(),
+  error: z20.string().optional()
+});
+var RoleProfileSchema = z20.object({
+  name: z20.string(),
+  description: z20.string().optional(),
   runtime: SourcedStringSchema,
   model: SourcedStringSchema,
   effort: SourcedStringSchema,
-  uses: z18.object({ skills: RoleUsesListSchema, guidance: RoleUsesListSchema, subagents: RoleUsesListSchema, plugins: RoleUsesListSchema, runtimeResources: RoleUsesListSchema }),
+  uses: z20.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: z20.array(StartupEntrySchema)
+});
+var RoleSeatSchema = z20.object({
+  rig: z20.string(),
+  rigId: z20.string(),
+  rigSpecPath: z20.string().optional(),
+  composed: z20.boolean(),
+  logicalId: z20.string(),
+  session: z20.string().optional(),
+  label: z20.string().optional(),
+  profile: z20.string(),
+  running: z20.boolean(),
+  activity: z20.string(),
   runtime: SourcedStringSchema,
   model: SourcedStringSchema,
   effort: SourcedStringSchema,
   cwd: SourcedStringSchema,
   cultureFile: SourcedStringSchema,
-  member: z18.string().optional(),
-  memberStartup: z18.array(StartupEntrySchema),
+  member: z20.string().optional(),
+  memberStartup: z20.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: z20.array(StartupEntrySchema),
+  live: z20.object({
+    resolvedSpec: z20.object({ name: z20.string().optional(), version: z20.string().optional(), hash: z20.string().optional() }),
+    resources: z20.array(RoleResourceSchema),
     /** In the order OpenRig returns them. */
-    startup: z18.array(StartupEntrySchema),
+    startup: z20.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: z20.array(z20.object({ id: z20.string(), trigger: z20.string().optional() })).optional()
   }).optional()
 });
-var RoleUnavailableSchema = z18.enum(["harness_prompt", "effective_settings", "delivered_content", "harness_own_files"]);
-var RoleDetailSchema = z18.object({
+var RoleUnavailableSchema = z20.enum(["harness_prompt", "effective_settings", "delivered_content", "harness_own_files"]);
+var RoleDetailSchema = z20.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: z20.object({
+    path: z20.string(),
+    relativePath: z20.string().optional(),
+    modifiedAt: z20.string().optional(),
+    copies: z20.array(z20.object({ kind: z20.literal("repo"), path: z20.string(), identical: z20.boolean(), modifiedAt: z20.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: z20.object({ path: z20.string(), absolutePath: z20.string(), origin: OriginSchema }).nullable(),
+  defaults: z20.object({ runtime: SourcedStringSchema, model: SourcedStringSchema, effort: SourcedStringSchema }),
+  imports: z20.array(RoleImportSchema),
+  importedBy: z20.array(z20.string()),
+  profiles: z20.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: z20.array(RoleResourceSchema),
+  seats: z20.array(RoleSeatSchema),
+  unavailable: z20.array(RoleUnavailableSchema),
+  warnings: z20.array(z20.string()),
+  openrigVersion: z20.string().optional()
+});
+var RoleErrorSchema = z20.string();
+var LibraryIdSchema = z20.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "not a library id");
+var OpenRigRolesSchema = z20.object({ type: z20.literal("openrig.roles"), requestId: z20.string().min(1).max(100), machineId: z20.string().optional() });
+var OpenRigRoleListSchema = z20.object({
+  type: z20.literal("openrig.roleList"),
+  requestId: z20.string(),
+  machineId: z20.string().optional(),
+  roles: z20.array(RoleSummarySchema),
+  openrigVersion: z20.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 = z20.object({ type: z20.literal("openrig.role"), requestId: z20.string().min(1).max(100), machineId: z20.string().optional(), roleId: LibraryIdSchema });
+var OpenRigRoleDetailSchema = z20.object({
+  type: z20.literal("openrig.roleDetail"),
+  requestId: z20.string(),
+  machineId: z20.string().optional(),
+  roleId: z20.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 = z20.object({
+  type: z20.literal("openrig.roleFile"),
+  requestId: z20.string().min(1).max(100),
+  machineId: z20.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: z20.string().min(1).max(4096)
+});
+var OpenRigRoleFileContentSchema = z20.object({
+  type: z20.literal("openrig.roleFileContent"),
+  requestId: z20.string(),
+  machineId: z20.string().optional(),
+  roleId: z20.string(),
+  path: z20.string(),
+  content: z20.string().optional(),
+  size: z20.number().int().min(0).optional(),
+  truncated: z20.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 z21 } from "zod";
+var MachineInventorySchema = z21.object({
+  id: z21.string().min(1).max(80),
+  label: z21.string().min(1).max(120),
+  online: z21.boolean(),
+  local: z21.boolean(),
+  sessions: z21.array(z21.object({ id: z21.string(), name: z21.string(), project: z21.string(), cwd: z21.string(), topic: z21.string().optional(), state: z21.string(), readOnly: z21.boolean() })).max(500),
+  folders: z21.array(z21.object({ project: z21.string(), cwd: z21.string() })).max(100)
+});
+var RoutingContextSchema = z21.object({
+  machines: z21.array(MachineInventorySchema).min(1).max(20),
+  history: z21.array(z21.object({ question: z21.string().max(2e4), answer: z21.string().max(2e4).optional(), machineId: z21.string().optional() })).max(50)
+});
+var RouteResultSchema = z21.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: z21.string().nullable(),
+  text: z21.string().min(1).max(2e4),
+  choices: z21.array(z21.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 z22 } from "zod";
+var ToolStatusSchema = z22.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z22.object({ path: z22.string().min(1), from: z22.string().min(1).optional(), change: z22.enum(["add", "edit", "delete", "write"]), diff: z22.string().optional() });
+var base = { id: z22.string().min(1), at: z22.string().datetime(), turn: z22.number().int().nonnegative(), helperId: z22.string().optional() };
+var ThreadItemSchema = z22.discriminatedUnion("kind", [
+  z22.object({ kind: z22.literal("prompt"), ...base, text: z22.string(), images: z22.array(AttachmentRefSchema).optional() }),
+  z22.object({ kind: z22.literal("message"), ...base, text: z22.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"),
+  z22.object({
+    kind: z22.literal("tool"),
     ...base,
-    tool: z20.string(),
-    label: z20.string(),
-    input: z20.string().optional(),
-    output: z20.string().optional(),
-    error: z20.string().optional(),
+    tool: z22.string(),
+    label: z22.string(),
+    input: z22.string().optional(),
+    output: z22.string().optional(),
+    error: z22.string().optional(),
     status: ToolStatusSchema,
-    durationMs: z20.number().nonnegative().optional(),
-    files: z20.array(FileChangeSchema).default([]),
-    byClose: z20.literal(true).optional(),
+    durationMs: z22.number().nonnegative().optional(),
+    files: z22.array(FileChangeSchema).default([]),
+    byClose: z22.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: z22.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional(),
+    imagesDropped: z22.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"]) }),
+  z22.object({ kind: z22.literal("permission"), ...base, tool: z22.string(), text: z22.string(), decision: z22.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z22.literal(true).optional() }),
+  z22.object({ kind: z22.literal("reply"), ...base, text: z22.string() }),
+  z22.object({ kind: z22.literal("helper"), ...base, task: z22.string(), agentType: z22.string().optional(), state: z22.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() }),
+  z22.object({
+    kind: z22.literal("sent"),
+    ...base,
+    to: z22.string(),
+    peer: z22.string().optional(),
+    summary: z22.string().optional(),
+    text: z22.string(),
+    status: z22.enum(["sending", "delivered", "read", "failed"]),
+    received: z22.string().optional(),
+    via: z22.literal("ledge").optional(),
+    /** The seat's own `rig send` (its Bash call), docs/mockups/ledge-openrig-messages.html: `rig.command` is what it ran. */
+    rig: RigInfoSchema.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() }),
+  z22.object({
+    kind: z22.literal("received"),
+    ...base,
+    from: z22.string(),
+    peer: z22.string().optional(),
+    text: z22.string(),
+    sent: z22.string().optional(),
+    /** An OpenRig `rig send` typed into this seat (`rig.kind` `message`): `from` is the envelope's sender, `text` its body. */
+    rig: RigInfoSchema.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"),
+  z22.object({
+    kind: z22.literal("notice"),
     ...base,
-    notice: z20.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
+    notice: z22.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: z22.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: z22.enum(TRANSMISSION_OPS).optional(),
+    outgoing: z22.literal(true).optional(),
+    name: z22.string().optional(),
+    peer: z22.string().optional(),
+    time: z22.string().optional(),
+    summary: z22.string().optional(),
+    status: z22.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
+    count: z22.number().int().positive().optional(),
+    recipients: z22.array(z22.string()).optional(),
+    reason: z22.string().optional(),
+    text: z22.string(),
+    /** An OpenRig block that is not a message: a row handed to this seat or passed by it (`handoff`, `outgoing` for its own),
+     *  a row unblocked, OpenRig's own notice, or an unreadable block; `text` is the body (unreadable: the block as is). */
+    rig: RigInfoSchema.optional()
   })
 ]);
 
 // ../protocol/src/mobile.ts
-import { z as z21 } from "zod";
-var RelayUrlSchema = z21.string().transform((v, ctx) => {
+import { z as z23 } from "zod";
+var RelayUrlSchema = z23.string().transform((v, ctx) => {
   const bad = () => {
-    ctx.addIssue({ code: z21.ZodIssueCode.custom, message: "invalid relay URL" });
-    return z21.NEVER;
+    ctx.addIssue({ code: z23.ZodIssueCode.custom, message: "invalid relay URL" });
+    return z23.NEVER;
   };
   let u;
   try {
@@ -1185,116 +1476,128 @@ 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 = z23.object({ enabled: z23.boolean(), relayUrl: RelayUrlSchema, terminalInput: z23.boolean().optional() });
+var MobileLinkStateSchema = z23.discriminatedUnion("state", [
+  z23.object({ state: z23.literal("off") }),
+  z23.object({ state: z23.literal("connecting") }),
+  z23.object({ state: z23.literal("online") }),
+  z23.object({ state: z23.literal("offline"), retryAt: z23.string().datetime(), error: z23.string() }),
+  z23.object({ state: z23.literal("signed_out"), reason: z23.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) })
+  z23.object({ state: z23.literal("unavailable"), error: z23.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 = z23.object({
+  id: z23.string(),
+  label: z23.string(),
+  code: z23.string().nullable(),
+  expiresAt: z23.string().datetime(),
+  state: z23.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
+});
+var MobileStateSchema = z23.object({
+  enabled: z23.boolean(),
+  relayUrl: z23.string(),
+  account: z23.object({ login: z23.string(), accountId: z23.string() }).nullable(),
+  signin: z23.object({ userCode: z23.string(), verificationUri: z23.string(), expiresAt: z23.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: z23.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: z23.array(z23.object({ id: z23.string(), label: z23.string(), approvedAt: z23.string(), online: z23.boolean(), lastSeenAt: z23.string().optional() })),
+  pairings: z23.array(MobilePairingSchema),
+  /** « Taper dans les terminaux depuis le téléphone »: absent from an older daemon, which has no phone terminal. */
+  terminalInput: z23.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 = z24.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 = z24.object({
+  name: z24.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: z24.string().datetime(),
+  source: z24.enum(["hook", "pane", "daemon"]),
+  tool: z24.string().optional(),
+  text: z24.string().optional(),
+  options: z24.array(z24.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: z24.array(z24.string()).optional(),
+  kind: z24.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: z24.string().optional(),
+  exitCode: z24.number().int().nullable().optional(),
+  helperId: z24.string().optional(),
   /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z22.string().optional(),
+  task: z24.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z22.boolean().optional(),
+  interrupt: z24.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: z24.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
   /** PostToolUse: some of the result's images were not kept. */
-  imagesDropped: z22.boolean().optional(),
+  imagesDropped: z24.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: z24.array(z24.object({ text: z24.string(), mode: z24.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: z24.string().optional(),
+  streaming: z24.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: z24.string().optional(),
+  questions: z24.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: z24.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: z24.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: z24.record(z24.string(), z24.unknown()).optional(),
   /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z22.string().optional(),
-  durationMs: z22.number().nonnegative().optional(),
+  output: z24.string().optional(),
+  durationMs: z24.number().nonnegative().optional(),
   /** PostToolUseFailure: the harness's error message. */
-  error: z22.string().optional(),
+  error: z24.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: z24.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: z24.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: z24.string().optional()
 });
-var RecentSchema = z22.object({ cwd: z22.string().min(1), project: z22.string().min(1), lastAt: z22.string().datetime() });
+var RecentSchema = z24.object({ cwd: z24.string().min(1), project: z24.string().min(1), lastAt: z24.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 = z24.object({
+  version: z24.string(),
+  install: z24.enum(["npm", "git", "unknown"]),
+  systemd: z24.boolean(),
+  manual: z24.string().optional(),
+  routing: z24.boolean().optional(),
+  archive: z24.boolean().optional(),
   /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
-  models: z22.boolean().optional(),
+  models: z24.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: z24.boolean().optional(),
   /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
-  modelSwitch: z22.boolean().optional(),
+  modelSwitch: z24.boolean().optional(),
+  /** Answers `session.commands`: the slash commands a session's agent offers. */
+  commands: z24.boolean().optional(),
   /** Takes `approval` on an OMP `session.launch` (auto mode). */
-  ompApproval: z22.boolean().optional(),
+  ompApproval: z24.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: z24.string().optional(),
+  mobile: z24.boolean().optional(),
   /** Answers `openrig.status` and `openrig.act`: drives OpenRig on its machine. */
-  openrig: z22.boolean().optional(),
+  openrig: z24.boolean().optional(),
   /** Answers `openrig.roles`, `openrig.role` and `openrig.roleFile`: reads OpenRig's roles (agent specs). */
-  openrigRoles: z22.boolean().optional()
-});
-var UpdateFailureSchema = z22.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z22.discriminatedUnion("type", [
+  openrigRoles: z24.boolean().optional(),
+  /** Answers `openrig.row`: a queue row's state, for the OpenRig task cards of a thread. */
+  openrigRows: z24.boolean().optional(),
+  /** Answers `openrig.asks` and `openrig.answer`: what OpenRig asks the person, and their answers (« À toi »). */
+  openrigAsks: z24.boolean().optional(),
+  /** Answers `openrig.goal.send`, `openrig.goals` and `openrig.goal.reply`: goals given to Max (lot 2). */
+  openrigGoals: z24.boolean().optional(),
+  /** Takes `session.broadcast` (its `ledge bridge` too, on this machine): a client sends it only when this is set. */
+  broadcast: z24.boolean().optional()
+});
+var UpdateFailureSchema = z24.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z24.discriminatedUnion("type", [
   SessionModelAcceptedSchema,
-  z22.object({ type: z22.literal("chat.routed"), qid: z22.string(), result: RouteResultSchema }),
+  z24.object({ type: z24.literal("chat.routed"), qid: z24.string(), result: RouteResultSchema }),
   DocumentContentSchema,
   DocumentErrorSchema,
   AttachmentStoredSchema,
@@ -1303,7 +1606,9 @@ var ServerMessageSchema = z22.discriminatedUnion("type", [
   ReposInfoSchema,
   ReposFoundSchema,
   ModelsListingSchema,
+  SessionCommandsListingSchema,
   OpenRigStateMessageSchema,
+  OpenRigRowStateSchema,
   OpenRigDoneSchema,
   OpenRigSpecListSchema,
   OpenRigLaunchedSchema,
@@ -1311,97 +1616,113 @@ var ServerMessageSchema = z22.discriminatedUnion("type", [
   OpenRigRoleListSchema,
   OpenRigRoleDetailSchema,
   OpenRigRoleFileContentSchema,
+  OpenRigAsksChangedSchema,
+  OpenRigAnsweredSchema,
+  OpenRigGoalSentSchema,
+  OpenRigGoalsChangedSchema,
+  OpenRigGoalRepliedSchema,
   /** `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 }),
+  z24.object({ type: z24.literal("snapshot"), sessions: z24.array(SessionSchema), recents: z24.array(RecentSchema).optional(), launcher: z24.array(z24.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z24.object({ type: z24.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()),
+  z24.object({
+    type: z24.literal("session.queue.restored"),
+    id: z24.string(),
+    texts: z24.array(z24.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: z24.array(z24.object({ text: z24.string(), attachments: z24.array(AttachmentIdSchema).optional() })).optional(),
+    imagesDropped: z24.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()) }),
+  z24.object({ type: z24.literal("session.removed"), id: z24.string() }),
+  z24.object({ type: z24.literal("session.preview"), id: z24.string(), lines: z24.array(z24.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 }),
+  z24.object({ type: z24.literal("session.thread"), id: z24.string(), items: z24.array(ThreadItemSchema) }),
+  z24.object({ type: z24.literal("session.thread.item"), id: z24.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() }),
+  z24.object({ type: z24.literal("session.launched"), id: z24.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) }),
+  z24.object({ type: z24.literal("session.closed"), qid: z24.string(), row: z24.number().int().min(0), id: z24.string(), how: z24.enum(["exit", "killed"]) }),
+  z24.object({ type: z24.literal("recents"), recents: z24.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(),
+  z24.object({
+    type: z24.literal("folder.listing"),
+    path: z24.string(),
+    parent: z24.string().nullable(),
+    entries: z24.array(z24.string()),
+    error: z24.string().optional(),
     /** The request this answers, when it carried one. */
-    requestId: z22.string().optional(),
+    requestId: z24.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: z24.array(z24.object({ name: z24.string(), branch: z24.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() }),
+  z24.object({ type: z24.literal("chat.step"), qid: z24.string(), step: ChatStepSchema }),
+  z24.object({ type: z24.literal("chat.delta"), qid: z24.string(), text: z24.string() }),
+  z24.object({ type: z24.literal("chat.done"), qid: z24.string(), text: z24.string(), at: z24.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(),
+  z24.object({ type: z24.literal("chat.acted"), rid: z24.string(), qid: z24.string(), done: z24.array(z24.number().int().min(0)), failed: z24.array(z24.object({
+    row: z24.number().int().min(0),
+    message: z24.string(),
     /** nothing was sent */
-    refused: z22.literal(true).optional()
+    refused: z24.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) }),
+  z24.object({ type: z24.literal("action.result"), rid: z24.string(), action: z24.string().min(1).max(40), row: ChatActionSchema.optional(), reason: z24.string().optional(), code: z24.string().optional() }),
+  z24.object({ type: z24.literal("chat.error"), qid: z24.string(), message: z24.string() }),
+  z24.object({ type: z24.literal("chat.history"), turns: z24.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"]) }),
+  z24.object({ type: z24.literal("update.progress"), version: z24.string(), step: z24.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() }),
+  z24.object({ type: z24.literal("update.failed"), version: z24.string(), reason: UpdateFailureSchema, detail: z24.string().optional(), command: z24.string().optional() }),
   /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z22.object({ type: z22.literal("machines"), machines: MachinesSchema }),
+  z24.object({ type: z24.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 }),
+  z24.object({ type: z24.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() }),
+  z24.object({ type: z24.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 }),
+  z24.object({ type: z24.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. */
+  z24.object({ type: z24.literal("terminal.holders"), holds: z24.array(z24.object({ id: z24.string(), device: z24.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() }),
+  z24.object({
+    type: z24.literal("message.ack"),
+    rid: z24.string(),
+    outcome: z24.enum(["accepted", "queued", "native", "refused"]),
+    reason: z24.string().optional(),
+    /** A broadcast's per-recipient outcome, by name. */
+    recipients: z24.object({ sent: z24.array(z24.string()), refused: z24.array(z24.object({ name: z24.string(), reason: z24.string() })) }).optional()
+  }),
+  /** The answer to a `session.broadcast`: who got it (`sent`) and who did not; `reason`: the whole broadcast was refused. */
+  z24.object({ type: z24.literal("session.broadcast.result"), rid: z24.string(), sent: z24.array(z24.object({ id: z24.string(), name: z24.string() })), refused: z24.array(z24.object({ name: z24.string(), reason: z24.string() })), reason: z24.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() }),
+  z24.object({ type: z24.literal("message.body"), id: z24.string(), from: z24.string().optional(), to: z24.string().optional(), at: z24.string().optional(), text: z24.string().optional(), reason: z24.string().optional() }),
   TaskResultSchema,
   SessionHandoverResultSchema,
   ContextPrefsMessageSchema,
   HandoverResultSchema,
   TaskUpdatedSchema,
-  z22.object({
-    type: z22.literal("error"),
-    message: z22.string(),
-    id: z22.string().optional(),
+  z24.object({
+    type: z24.literal("error"),
+    message: z24.string(),
+    id: z24.string().optional(),
     /** Le type du message client refusé. */
-    request: z22.string().optional(),
+    request: z24.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: z24.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 = z24.array(z24.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var ClientMessageSchema = z24.discriminatedUnion("type", [
+  z24.object({ type: z24.literal("chat.route"), qid: z24.string().min(1).max(100), text: z24.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
   DocumentReadSchema,
   AttachmentPutSchema,
   AttachmentCaptureSchema,
@@ -1409,7 +1730,9 @@ var ClientMessageSchema = z22.discriminatedUnion("type", [
   ReposInspectSchema,
   ReposScanSchema,
   ModelsListSchema,
+  SessionCommandsSchema,
   OpenRigStatusSchema,
+  OpenRigRowSchema,
   OpenRigActSchema,
   OpenRigSpecsSchema,
   OpenRigLaunchSchema,
@@ -1417,155 +1740,174 @@ var ClientMessageSchema = z22.discriminatedUnion("type", [
   OpenRigRolesSchema,
   OpenRigRoleSchema,
   OpenRigRoleFileSchema,
+  OpenRigAsksSchema,
+  OpenRigAnswerSchema,
+  OpenRigGoalSendSchema,
+  OpenRigGoalsSchema,
+  OpenRigGoalReplySchema,
   /** The overlay starts a session: `cwd` is a WSL path (`~` allowed), `name` a preferred bot name (the daemon picks a
    *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
    *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields
    *  but `rows`, `model` and `effort`. */
-  z22.object({
-    type: z22.literal("session.launch"),
+  z24.object({
+    type: z24.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: z24.string().min(1),
+    name: z24.string().optional(),
+    prompt: z24.string().optional(),
+    continue: z24.boolean().optional(),
+    qid: z24.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: z24.array(z24.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: z24.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(),
+  z24.object({
+    type: z24.literal("folder.list"),
+    path: z24.string().optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z22.string().optional(),
+    machineId: z24.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: z24.string().min(1).max(100).optional()
   }),
-  z22.object({
-    type: z22.literal("folder.create"),
-    parent: z22.string().min(1),
-    name: z22.string().min(1),
+  z24.object({
+    type: z24.literal("folder.create"),
+    parent: z24.string().min(1),
+    name: z24.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: z24.string().optional(),
+    requestId: z24.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() }),
+  z24.object({ type: z24.literal("session.answer"), id: z24.string(), requestId: z24.string().min(1).max(200), answers: z24.array(z24.object({ id: z24.string(), selected: z24.array(z24.string().max(2e3)).max(100), text: z24.string().max(2e4).optional() })).max(50), cancel: z24.boolean().optional() }),
+  z24.object({ type: z24.literal("session.reply"), id: z24.string(), text: z24.string(), attachments: z24.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(), steer: z24.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) }),
+  z24.object({ type: z24.literal("session.relay"), qid: z24.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) }),
+  z24.object({ type: z24.literal("session.relay.cancel"), qid: z24.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),
+  z24.object({
+    type: z24.literal("chat.act"),
+    rid: z24.string().min(1).max(100),
+    qid: z24.string().min(1),
     rows: launchRows.optional(),
-    confirmed: z22.literal(true).optional(),
+    confirmed: z24.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: z24.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() }),
+  z24.object({ type: z24.literal("chat.ignore"), qid: z24.string().min(1), undo: z24.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(),
+  z24.object({
+    type: z24.literal("action.run"),
+    rid: z24.string().min(1).max(100),
+    by: z24.string().min(1).optional(),
     /** `by`'s key (LEDGE_SESSION_KEY) */
-    key: z22.string().max(128).optional(),
+    key: z24.string().max(128).optional(),
     action: ActionIdSchema,
-    args: z22.record(z22.unknown()),
-    confirmed: z22.literal(true).optional()
+    args: z24.record(z24.unknown()),
+    confirmed: z24.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() }),
+  z24.object({ type: z24.literal("session.close"), qid: z24.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(),
+  z24.object({
+    type: z24.literal("session.decide"),
+    id: z24.string(),
     decision: DecisionSchema,
-    note: z22.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z24.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: z24.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() }),
+  z24.object({ type: z24.literal("session.focus"), id: z24.string() }),
+  z24.object({ type: z24.literal("session.kill"), id: z24.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() }),
+  z24.object({ type: z24.literal("session.interrupt"), id: z24.string(), restoreQueue: z24.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() }),
+  z24.object({ type: z24.literal("session.dismiss"), id: z24.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() }),
+  z24.object({ type: z24.literal("session.archive"), id: z24.string() }),
   /** Takes an archived session back out of the archive, as it was. */
-  z22.object({ type: z22.literal("session.restore"), id: z22.string() }),
+  z24.object({ type: z24.literal("session.restore"), id: z24.string() }),
   /** Starts the agent again on an archived session's conversation. */
-  z22.object({ type: z22.literal("session.resume"), id: z22.string() }),
+  z24.object({ type: z24.literal("session.resume"), id: z24.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() }),
+  z24.object({ type: z24.literal("session.model"), id: z24.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() }),
+  z24.object({ type: z24.literal("session.delete"), id: z24.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 }),
+  z24.object({ type: z24.literal("session.rename"), id: z24.string(), topic: z24.string().max(500) }),
+  z24.object({ type: z24.literal("session.thread"), id: z24.string() }),
+  z24.object({ type: z24.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(),
+  z24.object({
+    type: z24.literal("session.event"),
+    id: z24.string(),
     event: SessionEventSchema,
     agent: ToolSchema.optional(),
-    cwd: z22.string().optional(),
+    cwd: z24.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) }),
+  z24.object({ type: z24.literal("session.unregister"), id: z24.string(), exitCode: z24.number().int().nullable() }),
+  z24.object({ type: z24.literal("snapshot.request") }),
+  z24.object({ type: z24.literal("chat.ask"), qid: z24.string().min(1), text: z24.string(), images: z24.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
+  z24.object({ type: z24.literal("chat.cancel"), qid: z24.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") }),
+  z24.object({ type: z24.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) }),
+  z24.object({ type: z24.literal("update.daemon"), version: z24.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 }),
+  z24.object({ type: z24.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 }),
+  z24.object({ type: z24.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 }),
+  z24.object({ type: z24.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") }),
+  z24.object({ type: z24.literal("mobile.set"), enabled: z24.boolean(), relayUrl: RelayUrlSchema }),
+  z24.object({ type: z24.literal("mobile.signin") }),
+  z24.object({ type: z24.literal("mobile.signin.cancel") }),
+  z24.object({ type: z24.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) }),
+  z24.object({ type: z24.literal("mobile.retry") }),
+  z24.object({ type: z24.literal("mobile.pairing.approve"), id: z24.string().min(1).max(100) }),
+  z24.object({ type: z24.literal("mobile.pairing.deny"), id: z24.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) }),
+  z24.object({ type: z24.literal("mobile.device.revoke"), id: z24.string().min(1).max(100) }),
+  /** « Taper dans les terminaux depuis le téléphone »; turned off, every phone loses the hand. */
+  z24.object({ type: z24.literal("mobile.terminal"), input: z24.boolean() }),
+  /** « Reprendre la main »: the phone typing into the session's terminal goes back to reading it. */
+  z24.object({ type: z24.literal("terminal.release"), id: z24.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() }),
+  z24.object({ type: z24.literal("session.message"), rid: z24.string().min(1), from: z24.string().min(1), to: z24.string().min(1), text: z24.string().min(1).max(MESSAGE_MAX), summary: z24.string().max(SUMMARY_MAX).optional(), intercept: z24.boolean().optional() }),
+  /** The user writing to every session of a project, or to several sessions (ids or names). */
+  z24.object({
+    type: z24.literal("session.broadcast"),
+    rid: z24.string().min(1).max(100),
+    to: z24.union([z24.object({ project: z24.string().min(1).max(80) }), z24.object({ sessions: z24.array(z24.string().min(1)).min(1).max(BROADCAST_SESSIONS_MAX) })]),
+    text: z24.string().trim().min(1).max(MESSAGE_MAX),
+    summary: z24.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: z24.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) }),
+  z24.object({ type: z24.literal("message.read"), id: z24.string().min(1).max(40), by: z24.string().min(1) }),
   TaskCmdSchema,
   SessionHandoverSchema,
   ContextSetSchema,
@@ -1574,79 +1916,79 @@ var ClientMessageSchema = z22.discriminatedUnion("type", [
 ]);
 
 // ../protocol/src/relay.ts
-import { z as z23 } from "zod";
+import { z as z25 } 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 = z25.union([z25.literal("pc"), z25.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
+var RelayClientMessageSchema = z25.object({
+  type: z25.literal("send"),
   to: RelayPeerSchema,
-  body: z23.string().max(SEALED_MAX)
+  body: z25.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 = z25.discriminatedUnion("type", [
+  z25.object({ type: z25.literal("welcome"), accountId: z25.string(), self: RelayPeerSchema, online: z25.array(RelayPeerSchema) }),
+  z25.object({ type: z25.literal("deliver"), from: RelayPeerSchema, body: z25.string() }),
+  z25.object({ type: z25.literal("presence"), peer: RelayPeerSchema, online: z25.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"]),
+  z25.object({
+    type: z25.literal("error"),
+    code: z25.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 = z25.string().regex(/^[A-Za-z0-9_-]{87}$/);
+var Nonce = z25.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var Fingerprint = z25.string().regex(/^[A-Za-z0-9_-]{22}$/);
+var SealedFrameSchema = z25.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") })
+  z25.object({ k: z25.literal("hello"), e: KeyB64, f: Fingerprint }),
+  z25.object({ k: z25.literal("msg"), s: z25.string() }),
+  z25.object({ k: z25.literal("pair_commit"), c: Nonce, label: z25.string().trim().min(1).max(PAIR_LABEL_MAX) }),
+  z25.object({ k: z25.literal("pair_offer"), pc: KeyB64, n: Nonce }),
+  z25.object({ k: z25.literal("pair_reveal"), d: KeyB64, n: Nonce }),
+  z25.object({ k: z25.literal("pair_ok") }),
+  z25.object({ k: z25.literal("pair_no") }),
+  z25.object({ k: z25.literal("denied") }),
+  z25.object({ k: z25.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 z26 } from "zod";
+var DeviceStartResponseSchema = z26.object({
+  deviceCode: z26.string().min(1),
+  userCode: z26.string().min(1),
+  verificationUri: z26.string().min(1),
+  expiresIn: z26.number().int().positive(),
+  interval: z26.number().int().positive()
+});
+var DevicePollResponseSchema = z26.discriminatedUnion("status", [
+  z26.object({ status: z26.literal("pending") }),
+  z26.object({ status: z26.literal("slow_down"), interval: z26.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") })
+  z26.object({ status: z26.literal("ok"), token: z26.string().min(1), accountId: z26.string().min(1), login: z26.string().min(1) }),
+  z26.object({ status: z26.literal("expired") }),
+  z26.object({ status: z26.literal("denied") }),
+  z26.object({ status: z26.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 = z26.object({ revoked: z26.number().int().min(0) });
+var MeResponseSchema = z26.object({
+  accountId: z26.string().min(1),
+  login: z26.string().min(1),
   peer: RelayPeerSchema,
-  kind: z24.enum(["pc", "device"])
+  kind: z26.enum(["pc", "device"])
 });
 
 // ../protocol/src/phone.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 
 // ../protocol/src/push.ts
-import { z as z25 } from "zod";
-var B64U = z25.string().regex(/^[A-Za-z0-9_-]*$/);
+import { z as z27 } from "zod";
+var B64U = z27.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,67 +2005,70 @@ function pushEndpointAllowed(url) {
     return host.length > suffix.length && host.endsWith(suffix);
   });
 }
-var PushSendSchema = z25.object({
-  endpoint: z25.string().url().max(1024),
+var PushSendSchema = z27.object({
+  endpoint: z27.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: z27.number().int().min(0).max(86400),
+  urgency: z27.enum(["normal", "high"]),
+  topic: z27.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+});
+var PushSendResultSchema = z27.object({
+  result: z27.enum(["sent", "gone", "failed"]),
+  status: z27.number().int().optional()
+});
+var PushSubscriptionSchema = z27.object({
+  endpoint: z27.string().url().max(1024).refine(pushEndpointAllowed),
+  keys: z27.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
+});
+var PushPayloadSchema = z27.object({
+  v: z27.literal(1),
+  kind: z27.enum(["request", "question", "finished", "chat", "decision"]),
+  title: z27.string().max(80),
+  body: z27.string().max(120),
+  url: z27.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
+  badge: z27.number().int().min(0).max(999),
+  tag: z27.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
 });
 
 // ../protocol/src/phone.ts
+var PHONE_ROW_SUMMARY_MAX = 200;
+var PhoneRigRowSchema = RigRowSchema.extend({ summary: z28.string().max(PHONE_ROW_SUMMARY_MAX).optional() });
+var PhoneRowErrorSchema = z28.enum(["not_found", "unavailable"]);
 var PHONE_PROTOCOL = 1;
 var utf8 = new TextEncoder();
 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 = z28.enum(["pending", "in_progress", "completed"]);
+var PhoneChecklistSchema = z28.object({
+  tasks: z28.array(z28.object({ text: z28.string().max(CHECKLIST_TEXT_MAX), status: ChecklistStatusSchema })).max(CHECKLIST_TASKS_MAX),
+  done: z28.number().int().nonnegative(),
+  total: z28.number().int().nonnegative(),
+  cut: z28.literal(true).optional()
+});
+var PhoneChecklistSummarySchema = z28.object({
+  done: z28.number().int().nonnegative(),
+  total: z28.number().int().nonnegative(),
+  current: z28.string().max(CHECKLIST_TEXT_MAX).optional(),
+  cut: z28.literal(true).optional()
+});
+var RiskSchema = z28.enum(["low", "high"]);
+var RiskReasonSchema = z28.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 = z28.string().uuid();
+var OperationStatusSchema = z28.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z28.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired", "scheduled", ...ModelRefusalSchema.options]);
+var CapabilitiesSchema = z28.object({
   /** A question can be answered in free text. */
-  freeTextAnswer: z26.boolean(),
+  freeTextAnswer: z28.boolean(),
   /** The session's accept/deny can be typed; absent = true. */
-  decide: z26.boolean().optional(),
+  decide: z28.boolean().optional(),
   /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z26.boolean().optional()
+  questions: z28.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 = z28.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z28.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z28.literal(true).optional() });
+var SwitchableSessionSchema = SessionSchema.extend({ canSwitch: z28.literal(true).optional() });
 var PhoneSessionSchema = SwitchableSessionSchema.pick({
   id: true,
   name: true,
@@ -1751,290 +2096,403 @@ 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: z28.boolean(),
+  handover: z28.object({ state: HandoverStateSchema, toName: z28.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: z28.literal(true).optional()
 });
-var B64U2 = z26.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z26.object({
+var B64U2 = z28.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z28.object({
   id: B64U2.max(1366),
   publicKey: B64U2.max(2048),
-  alg: z26.union([z26.literal(-7), z26.literal(-257)]),
+  alg: z28.union([z28.literal(-7), z28.literal(-257)]),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
-  transports: z26.array(z26.string().max(20)).max(8).optional()
+  transports: z28.array(z28.string().max(20)).max(8).optional()
 });
-var AssertionSchema = z26.object({
+var AssertionSchema = z28.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 = z28.enum(["register", "decide", "launch", "close", "act", "pc", "terminal", "rig"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z26.object({
-  project: z26.string().max(80),
+var PhoneChatProposalSchema = z28.object({
+  project: z28.string().max(80),
   tool: ToolSchema,
-  prompt: z26.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z26.string().optional(),
-  failed: z26.literal(true).optional()
+  prompt: z28.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z28.string().optional(),
+  failed: z28.literal(true).optional()
 }).strict();
-var PhoneChatRelaySchema = z26.object({
-  id: z26.string().min(1),
-  name: z26.string(),
+var PhoneChatRelaySchema = z28.object({
+  id: z28.string().min(1),
+  name: z28.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: z28.string().max(TOOL_TEXT_MAX),
+  status: z28.enum(["queued", "sent"]).optional(),
+  sentAt: z28.string().datetime().optional(),
+  failed: z28.literal(true).optional(),
   /** With `failed`: why, as the PC's code (never its text). */
-  code: z26.string().max(40).optional()
+  code: z28.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 = z28.enum(["exit", "killed"]);
+var PhoneChatCloseSchema = z28.object({
+  id: z28.string().min(1),
+  name: z28.string(),
   tool: ToolSchema,
   how: CloseHowSchema.optional(),
-  closedAt: z26.string().datetime().optional(),
-  failed: z26.literal(true).optional()
+  closedAt: z28.string().datetime().optional(),
+  failed: z28.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 = z28.object({
+  to: z28.string().max(80),
+  toName: z28.string().max(80).optional(),
+  title: z28.string().max(200),
+  text: z28.string().max(TOOL_TEXT_MAX).optional(),
+  taskId: z28.string().max(40).optional(),
+  ownerName: z28.string().max(80).optional(),
+  state: z28.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
+  failed: z28.literal(true).optional()
 }).strict();
-var PhoneChatActionSchema = z26.object({
-  action: z26.string().min(1).max(40),
-  summary: z26.string().max(300),
+var PhoneChatActionSchema = z28.object({
+  action: z28.string().min(1).max(40),
+  summary: z28.string().max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z26.string().max(TOOL_TEXT_MAX).optional(),
-  detailCut: z26.literal(true).optional(),
+  detail: z28.string().max(TOOL_TEXT_MAX).optional(),
+  detailCut: z28.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z26.string().max(100).optional(),
+  session: z28.string().max(100).optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z26.string().datetime().optional(),
-  code: z26.string().max(40).optional()
+  doneAt: z28.string().datetime().optional(),
+  code: z28.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 = z28.object({
+  id: z28.string().max(40),
+  title: z28.string().max(200),
+  owner: z28.string().max(100),
+  ownerName: z28.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: z28.string().max(100).optional(),
+  giverName: z28.string().max(80).optional(),
+  text: z28.string().max(TOOL_TEXT_MAX).optional(),
+  state: z28.enum(["open", "taken", "done", "refused", "dropped"]),
+  result: z28.string().max(TOOL_TEXT_MAX).optional(),
+  cut: z28.literal(true).optional(),
+  at: z28.string(),
+  updatedAt: z28.string(),
+  seen: z28.literal(true).optional()
 }).strict();
-var ChatErrorCodeSchema = z26.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z26.object({
+var ChatErrorCodeSchema = z28.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z28.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: z28.string().max(MESSAGE_MAX),
+  askedAt: z28.string().datetime(),
+  steps: z28.array(PhoneChatStepSchema).max(50),
+  answer: z28.string().max(THREAD_TEXT_MAX).optional(),
+  answeredAt: z28.string().datetime().optional(),
   error: ChatErrorCodeSchema.optional(),
-  proposals: z26.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  proposals: z28.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: z28.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
+  cut: z28.literal(true).optional(),
+  tasks: z28.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
+  actions: z28.array(PhoneChatActionSchema).min(1).max(MAX_PROPOSALS).optional(),
+  ignoredAt: z28.string().datetime().optional(),
+  attachments: z28.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 = z28.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z28.string().min(1).max(64) });
+var CardRowsSchema = z28.array(z28.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 = z28.enum(["update", "restart"]);
+var TerminalIdSchema = z28.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 = z28.number().int().min(1).max(1e4);
+var TermReleaseWhySchema = z28.enum(["asked", "pc", "idle", "expired", "background", "link"]);
+var TermExitWhySchema = z28.enum(["ended", "gone", "closed", "superseded", "failed"]);
+var PhoneClientMessageSchema = z28.discriminatedUnion("type", [
+  z28.object({ type: z28.literal("snapshot.request") }),
+  z28.object({ type: z28.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 }),
+  z28.object({ type: z28.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() }),
+  z28.object({ type: z28.literal("session.watch"), id: sessionId.nullable() }),
+  z28.object({ type: z28.literal("session.read"), id: sessionId, at: z28.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"),
+  z28.object({
+    type: z28.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: z28.string().regex(SEMVER).optional(),
+    /** A `rig` challenge: the OpenRig row and the exact answer it covers. */
+    qitem: z28.string().min(1).max(200).optional(),
+    answer: HumanAnswerSchema.optional()
   }),
-  z26.object({ type: z26.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z26.object({
-    type: z26.literal("session.decide"),
+  z28.object({ type: z28.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z28.object({
+    type: z28.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z26.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z28.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"),
+  z28.object({
+    type: z28.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z26.string().max(MESSAGE_MAX),
-    attachments: z26.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+    text: z28.string().max(MESSAGE_MAX),
+    attachments: z28.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"),
+  z28.object({
+    type: z28.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: z28.string().min(1).max(200),
+    answers: z28.array(z28.object({ id: z28.string().max(200), selected: z28.array(z28.string().max(2e3)).max(100), text: z28.string().max(2e4).optional() })).max(50),
+    cancel: z28.literal(true).optional(),
     expect: PhoneExpectSchema
   }),
-  z26.object({ type: z26.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  z28.object({ type: z28.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() }),
+  z28.object({ type: z28.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() }),
+  z28.object({ type: z28.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() }),
+  z28.object({ type: z28.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`. */
+  z28.object({ type: z28.literal("session.broadcast"), op: OperationIdSchema, sessions: z28.array(sessionId).min(1).max(BROADCAST_SESSIONS_MAX), text: z28.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 }),
+  z28.object({ type: z28.literal("models.list"), tool: ToolSchema }),
+  /** The slash commands of a session's agent, for the « / » list of its field. */
+  z28.object({ type: z28.literal("session.commands"), id: sessionId }),
+  /** A queue row's state, for an OpenRig task card: asked while the card shows and every `RIG_ROW_REFRESH_MS` (`daemon.rigRows`). */
+  z28.object({ type: z28.literal("openrig.row"), qitem: QitemIdSchema }),
   /** The phone drops its passkey from the daemon. */
-  z26.object({ type: z26.literal("device.forget"), op: OperationIdSchema }),
+  z28.object({ type: z28.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 }),
+  z28.object({ type: z28.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z28.object({ type: z28.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") }),
+  z28.object({ type: z28.literal("chat.ask"), qid: OperationIdSchema, text: z28.string().trim().max(MESSAGE_MAX), attachments: z28.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
+  z28.object({ type: z28.literal("chat.cancel"), qid: OperationIdSchema }),
+  z28.object({ type: z28.literal("chat.reset") }),
+  z28.object({ type: z28.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: z28.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 }),
+  z28.object({ type: z28.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() }),
+  z28.object({ type: z28.literal("chat.relay.cancel"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z28.object({ type: z28.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  z28.object({ type: z28.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) }),
+  z28.object({ type: z28.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z28.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"),
+  z28.object({
+    type: z28.literal("chat.act"),
     op: OperationIdSchema,
     qid: OperationIdSchema,
     rows: CardRowsSchema.optional(),
-    confirmed: z26.literal(true).optional(),
+    confirmed: z28.literal(true).optional(),
     assertion: AssertionSchema.optional(),
     /** « Refuser », as the local `chat.act`: no passkey, no confirmation. */
-    deny: z26.literal(true).optional()
+    deny: z28.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() }),
+  z28.object({ type: z28.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z28.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) }),
+  z28.object({ type: z28.literal("task.seen"), op: OperationIdSchema, task: z28.string().min(1).max(40) }),
+  /** Streams a session's pane, read-only; answered by `term.opened` or `operation.result` (rejected). */
+  z28.object({ type: z28.literal("term.open"), op: OperationIdSchema, id: sessionId }),
+  /** « Prendre la main »: passkey, purpose `terminal`, over the session; answered by `term.held` or `operation.result` (rejected). */
+  z28.object({ type: z28.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. */
+  z28.object({ type: z28.literal("term.input"), tid: TerminalIdSchema, n: z28.number().int().nonnegative(), data: z28.string().min(1).max(TERM_INPUT_MAX) }),
+  /** « Rendre la main »: back to read-only. */
+  z28.object({ type: z28.literal("term.release"), tid: TerminalIdSchema }),
+  /** The phone saw a gap in `seq`: a fresh `term.opened`, please. */
+  z28.object({ type: z28.literal("term.resync"), tid: TerminalIdSchema }),
+  z28.object({ type: z28.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() }),
+  z28.object({ type: z28.literal("presence"), visible: z28.boolean() }),
+  /** « À toi » (lot 3): what OpenRig on this PC asks the person, then pushed whole when it changes (`openrig.asks`). */
+  z28.object({ type: z28.literal("openrig.asks") }),
+  /** The person's answer to an OpenRig row. A choice, words or a resolve carries an assertion of purpose `rig` bound to that row and that
+   *  answer; « Vu » (`seen`) needs none. */
+  z28.object({ type: z28.literal("openrig.answer"), op: OperationIdSchema, qitemId: z28.string().min(1).max(200), answer: HumanAnswerSchema, assertion: AssertionSchema.optional() }),
   /** 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(),
+  z28.object({ type: z28.literal("daemon.update"), ...pcOp, version: z28.string().regex(SEMVER) }).strict(),
   /** Restarts the PC's daemon without installing anything. Passkey, purpose `pc`. */
-  z26.object({ type: z26.literal("daemon.restart"), ...pcOp }).strict()
+  z28.object({ type: z28.literal("daemon.restart"), ...pcOp }).strict()
 ]);
-var PhoneModelChoiceSchema = z26.object({
+var PhoneModelChoiceSchema = z28.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: z28.string().max(80),
+  description: z28.string().max(200).optional(),
+  efforts: z28.array(EffortSchema).max(8).optional(),
   defaultEffort: EffortSchema.optional(),
-  isDefault: z26.boolean().optional()
+  isDefault: z28.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: z28.string().max(200).optional() }).strict();
+var PhoneServerMessageSchema = z28.discriminatedUnion("type", [
+  z28.object({ type: z28.literal("snapshot"), protocol: z28.literal(PHONE_PROTOCOL), sessions: z28.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z28.object({
+    version: z28.string(),
+    name: z28.string().max(40),
+    boot: z28.string().uuid().optional(),
     /** The daemon takes `session.model`. */
-    models: z26.literal(true).optional(),
+    models: z28.literal(true).optional(),
     /** The daemon sends `session.checklist` and a session's `checklist` summary. */
-    checklist: z26.literal(true).optional(),
+    checklist: z28.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: z28.literal(true).optional(),
+    restart: z28.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: z28.literal(true).optional(),
+    /** The daemon streams a session's terminal (`term.open`). */
+    terminal: z28.literal(true).optional(),
+    /** The PC lets a phone type into a terminal (`term.hold`): its setting is on. */
+    terminalInput: z28.literal(true).optional(),
+    /** The daemon answers `session.commands`. */
+    commands: z28.literal(true).optional(),
+    /** The daemon answers `openrig.row`. */
+    rigRows: z28.literal(true).optional(),
+    /** The daemon answers `openrig.asks` and `openrig.answer` (« À toi »). */
+    openrig: z28.literal(true).optional(),
+    /** The daemon takes `session.broadcast` (« Écrire au groupe »). */
+    broadcast: z28.literal(true).optional()
+  }), device: z28.object({ confirm: z28.boolean(), push: z28.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z28.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  /** « À toi » on this PC: the answer to `openrig.asks`, then each change, whole. */
+  z28.object({ type: z28.literal("openrig.asks"), channel: HumanChannelSchema, asks: z28.array(HumanAskSchema), partial: z28.literal(true).optional(), truncated: z28.literal(true).optional() }),
+  /** An answer's end, as on the desktop (`openrig.answered`), under the phone's `op`. `rejected`: the device check refused it (`reason`). */
+  z28.object({
+    type: z28.literal("openrig.answered"),
+    op: OperationIdSchema,
+    qitemId: z28.string(),
+    ok: z28.boolean(),
+    outcome: z28.enum(["recorded", "answered", "already"]).optional(),
+    remaining: z28.array(z28.string()).optional(),
+    replyId: z28.string().optional(),
+    error: HumanAnswerErrorSchema.optional(),
+    message: z28.string().max(500).optional(),
+    rejected: z28.enum(["confirm_required", "assertion_invalid", "assertion_expired", "unavailable"]).optional()
+  }),
+  z28.object({ type: z28.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z28.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z28.number().int().positive() }),
+  z28.object({ type: z28.literal("session.updated"), session: PhoneSessionSchema }),
+  z28.object({ type: z28.literal("session.removed"), id: z28.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() }),
+  z28.object({ type: z28.literal("session.checklist"), id: z28.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()) }),
+  z28.object({ type: z28.literal("session.pending"), id: z28.string(), pending: PhonePendingSchema }),
+  z28.object({ type: z28.literal("session.preview"), id: z28.string(), lines: z28.array(z28.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"),
+  z28.object({ type: z28.literal("session.thread"), id: z28.string(), items: z28.array(ThreadItemSchema), cut: z28.array(z28.string()), more: z28.boolean() }),
+  z28.object({ type: z28.literal("session.thread.item"), id: z28.string(), item: ThreadItemSchema, cut: z28.literal(true).optional() }),
+  z28.object({
+    type: z28.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: z28.array(z28.string().max(100)).max(BROADCAST_SESSIONS_MAX).optional(),
+    refused: z28.array(z28.object({ name: z28.string().max(100), reason: z28.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() }),
+  z28.object({ type: z28.literal("models.listing"), tool: ToolSchema, models: z28.array(PhoneModelChoiceSchema).max(40), error: z28.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 }),
+  z28.object({ type: z28.literal("session.model.failed"), id: z28.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. */
+  z28.object({ type: z28.literal("session.commands.listing"), id: z28.string(), commands: z28.array(PhoneSlashCommandSchema).max(PHONE_COMMANDS_MAX), error: z28.literal(true).optional() }),
+  /** A queue row's state, answering `openrig.row`: `row`, or `error`. */
+  z28.object({ type: z28.literal("openrig.rowState"), qitem: z28.string(), row: PhoneRigRowSchema.optional(), error: PhoneRowErrorSchema.optional() }),
+  z28.object({ type: z28.literal("chat.history"), turns: z28.array(PhoneChatTurnSchema).max(50) }),
+  z28.object({ type: z28.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 }),
+  z28.object({ type: z28.literal("chat.delta"), qid: OperationIdSchema, text: z28.string().max(THREAD_TEXT_MAX) }),
+  z28.object({ type: z28.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z28.object({ type: z28.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"]) }),
+  z28.object({ type: z28.literal("daemon.progress"), version: z28.string().max(40), step: z28.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 }),
+  z28.object({ type: z28.literal("daemon.failed"), version: z28.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 }),
+  z28.object({ type: z28.literal("tasks"), tasks: z28.array(PhoneTaskSchema).max(200) }),
+  z28.object({ type: z28.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. */
+  z28.object({
+    type: z28.literal("term.opened"),
+    op: OperationIdSchema.optional(),
+    tid: TerminalIdSchema,
+    id: z28.string(),
+    cols: TermDimSchema,
+    rows: TermDimSchema,
+    screen: z28.string().max(TERM_SCREEN_MAX),
+    cursor: z28.object({ x: z28.number().int().nonnegative(), y: z28.number().int().nonnegative() }),
+    seq: z28.number().int().nonnegative(),
+    /** Read-only for good: a subagent's page shows its parent's pane. */
+    readOnly: z28.literal(true).optional()
+  }),
+  /** What the pane printed since the last one; `seq` + 1 each time. */
+  z28.object({ type: z28.literal("term.output"), tid: TerminalIdSchema, seq: z28.number().int().nonnegative(), data: z28.string().min(1).max(TERM_OUTPUT_MAX) }),
+  z28.object({ type: z28.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. */
+  z28.object({ type: z28.literal("term.held"), tid: TerminalIdSchema, until: z28.string().datetime() }),
+  z28.object({ type: z28.literal("term.released"), tid: TerminalIdSchema, why: TermReleaseWhySchema }),
+  z28.object({ type: z28.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() })
+  z28.object({ type: z28.literal("error"), code: z28.enum(["invalid", "unknown_session", "too_large"]), request: z28.string().max(40).optional() })
 ]);
 
+// ../protocol/src/media.ts
+import { z as z29 } from "zod";
+var MediaCommandSchema = z29.enum(["previous", "play_pause", "next"]);
+var ARTWORK_MAX_BYTES = 512 * 1024;
+var NowPlayingSchema = z29.object({
+  /** The track's title; a session without one is not reported (nothing to show). */
+  title: z29.string().min(1),
+  /** '' when the player gives none (a web video often has no artist). */
+  artist: z29.string(),
+  album: z29.string().optional(),
+  /** The cover as a `data:image/…;base64,` URL; left out when the player has none, or it is over ARTWORK_MAX_BYTES. It can
+   *  arrive in a later event than the track itself: players often publish the thumbnail a moment after the title. */
+  artwork: z29.string().startsWith("data:image/").optional(),
+  /** True while it plays; a paused session is still reported (with false), `null` means no media session at all. */
+  playing: z29.boolean(),
+  /** What the player accepts now; a control it refuses is disabled, not hidden, at the front's choice. */
+  can: z29.object({ previous: z29.boolean(), playPause: z29.boolean(), next: z29.boolean() }),
+  /** The player: SMTC's source app id (`Spotify.exe`, `MSEdge`, a packaged app's AUMID), and its display name when
+   *  Windows knows one. Several players can hold a session: the one reported is the one playing (Windows' current one
+   *  first), else Windows' current one. Commands go to that same player. */
+  player: z29.object({ id: z29.string().min(1), name: z29.string().optional() })
+});
+var NowPlayingStateSchema = NowPlayingSchema.nullable();
+
 // src/imageInfo.ts
 var ok = (mime, width, height) => width > 0 && height > 0 ? { mime, width, height } : null;
 function jpeg(b) {