@paradow/ledge 0.35.0 → 0.36.0

package/dist/cli/reduceWorker.js

@@ -729,7 +729,7 @@ var ProjectsSchema = z14.object({ projects: z14.array(ProjectSchema).max(100), r
 });
 
 // ../protocol/src/messages.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // ../protocol/src/repos.ts
 import { z as z15 } from "zod";
@@ -916,92 +916,263 @@ var OpenRigReseatedSchema = z17.object({
   linksUnsupported: z17.boolean().optional()
 });
 
-// ../protocol/src/routing.ts
+// ../protocol/src/openrigRoles.ts
 import { z as z18 } from "zod";
-var MachineInventorySchema = z18.object({
-  id: z18.string().min(1).max(80),
-  label: z18.string().min(1).max(120),
-  online: z18.boolean(),
-  local: z18.boolean(),
-  sessions: z18.array(z18.object({ id: z18.string(), name: z18.string(), project: z18.string(), cwd: z18.string(), topic: z18.string().optional(), state: z18.string(), readOnly: z18.boolean() })).max(500),
-  folders: z18.array(z18.object({ project: z18.string(), cwd: z18.string() })).max(100)
-});
-var RoutingContextSchema = z18.object({
-  machines: z18.array(MachineInventorySchema).min(1).max(20),
-  history: z18.array(z18.object({ question: z18.string().max(2e4), answer: z18.string().max(2e4).optional(), machineId: z18.string().optional() })).max(50)
-});
-var RouteResultSchema = z18.object({
+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() })
+]);
+var SourcedStringSchema = z18.object({ value: z18.string().nullable(), origin: OriginSchema });
+var RoleResourceCategorySchema = z18.enum(["skill", "guidance", "plugin", "subagent", "runtime_resource"]);
+var RoleResourceSchema = z18.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(),
+  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(),
+  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()),
+  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()),
+  /** 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(),
+  runtime: SourcedStringSchema,
+  model: SourcedStringSchema,
+  effort: SourcedStringSchema,
+  uses: z18.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(),
+  runtime: SourcedStringSchema,
+  model: SourcedStringSchema,
+  effort: SourcedStringSchema,
+  cwd: SourcedStringSchema,
+  cultureFile: SourcedStringSchema,
+  member: z18.string().optional(),
+  memberStartup: z18.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),
+    /** In the order OpenRig returns them. */
+    startup: z18.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()
+  }).optional()
+});
+var RoleUnavailableSchema = z18.enum(["harness_prompt", "effective_settings", "delivered_content", "harness_own_files"]);
+var RoleDetailSchema = z18.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() }))
+  }),
+  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),
+  /** 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(),
+  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(),
+  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(),
+  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(),
+  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({
   /** Null means an answer or a clarification, never an implicit local destination. */
-  machineId: z18.string().nullable(),
-  text: z18.string().min(1).max(2e4),
-  choices: z18.array(z18.string()).max(20).optional()
+  machineId: z19.string().nullable(),
+  text: z19.string().min(1).max(2e4),
+  choices: z19.array(z19.string()).max(20).optional()
 });
 
 // ../protocol/src/thread.ts
-import { z as z19 } from "zod";
-var ToolStatusSchema = z19.enum(["running", "success", "failed", "unknown"]);
-var FileChangeSchema = z19.object({ path: z19.string().min(1), from: z19.string().min(1).optional(), change: z19.enum(["add", "edit", "delete", "write"]), diff: z19.string().optional() });
-var base = { id: z19.string().min(1), at: z19.string().datetime(), turn: z19.number().int().nonnegative(), helperId: z19.string().optional() };
-var ThreadItemSchema = z19.discriminatedUnion("kind", [
-  z19.object({ kind: z19.literal("prompt"), ...base, text: z19.string(), images: z19.array(AttachmentRefSchema).optional() }),
-  z19.object({ kind: z19.literal("message"), ...base, text: z19.string() }),
+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() }),
   /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row; `byClose`: a question
    *  dismissed by Ledge closing the session. */
-  z19.object({
-    kind: z19.literal("tool"),
+  z20.object({
+    kind: z20.literal("tool"),
     ...base,
-    tool: z19.string(),
-    label: z19.string(),
-    input: z19.string().optional(),
-    output: z19.string().optional(),
-    error: z19.string().optional(),
+    tool: z20.string(),
+    label: z20.string(),
+    input: z20.string().optional(),
+    output: z20.string().optional(),
+    error: z20.string().optional(),
     status: ToolStatusSchema,
-    durationMs: z19.number().nonnegative().optional(),
-    files: z19.array(FileChangeSchema).default([]),
-    byClose: z19.literal(true).optional(),
+    durationMs: z20.number().nonnegative().optional(),
+    files: z20.array(FileChangeSchema).default([]),
+    byClose: z20.literal(true).optional(),
     /** Images the tool returned (a browser screenshot), in order; `imagesDropped`: some were not kept. */
-    images: z19.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional(),
-    imagesDropped: z19.literal(true).optional()
+    images: z20.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional(),
+    imagesDropped: z20.literal(true).optional()
   }),
   /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again;
    *  `byClose`: denied by Ledge closing the session. */
-  z19.object({ kind: z19.literal("permission"), ...base, tool: z19.string(), text: z19.string(), decision: z19.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z19.literal(true).optional() }),
-  z19.object({ kind: z19.literal("reply"), ...base, text: z19.string() }),
-  z19.object({ kind: z19.literal("helper"), ...base, task: z19.string(), agentType: z19.string().optional(), state: z19.enum(["working", "exited"]) }),
+  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"]) }),
   /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread, `via` set when Ledge's mailbox carries it. */
-  z19.object({ kind: z19.literal("sent"), ...base, to: z19.string(), peer: z19.string().optional(), summary: z19.string().optional(), text: z19.string(), status: z19.enum(["sending", "delivered", "read", "failed"]), received: z19.string().optional(), via: z19.literal("ledge").optional() }),
+  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() }),
   /** A message another agent sent to this session; `from` is its from-name (else its address), `sent` the paired item's id in the peer's thread. */
-  z19.object({ kind: z19.literal("received"), ...base, from: z19.string(), peer: z19.string().optional(), text: z19.string(), sent: z19.string().optional() }),
+  z20.object({ kind: z20.literal("received"), ...base, from: z20.string(), peer: z20.string().optional(), text: z20.string(), sent: z20.string().optional() }),
   /** An automated notice of the agent's harness about messages between sessions (Claude Code's `[Cross-session idle
    *  notice]` / `[Cross-session delivery notice]`): a system event, never the user's words. `name` is the session it is
    *  about as quoted, `peer` its Ledge session id; a delivery notice says the outcome of `count` messages to `recipients`. */
-  z19.object({
-    kind: z19.literal("notice"),
+  z20.object({
+    kind: z20.literal("notice"),
     ...base,
-    notice: z19.enum(["idle", "exited", "unavailable", "expired", "delivery", "other"]),
+    notice: z20.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: z19.string().optional(),
+    task: z20.string().optional(),
     /** A task this session handed over (`outgoing`), and how (issue #92). */
-    taskOp: z19.enum(TRANSMISSION_OPS).optional(),
-    outgoing: z19.literal(true).optional(),
-    name: z19.string().optional(),
-    peer: z19.string().optional(),
-    time: z19.string().optional(),
-    summary: z19.string().optional(),
-    status: z19.enum(["held", "denied", "expired", "delivered", "refused", "dropped", "unknown"]).optional(),
-    count: z19.number().int().positive().optional(),
-    recipients: z19.array(z19.string()).optional(),
-    reason: z19.string().optional(),
-    text: z19.string()
+    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()
   })
 ]);
 
 // ../protocol/src/mobile.ts
-import { z as z20 } from "zod";
-var RelayUrlSchema = z20.string().transform((v, ctx) => {
+import { z as z21 } from "zod";
+var RelayUrlSchema = z21.string().transform((v, ctx) => {
   const bad = () => {
-    ctx.addIssue({ code: z20.ZodIssueCode.custom, message: "invalid relay URL" });
-    return z20.NEVER;
+    ctx.addIssue({ code: z21.ZodIssueCode.custom, message: "invalid relay URL" });
+    return z21.NEVER;
   };
   let u;
   try {
@@ -1014,114 +1185,116 @@ var RelayUrlSchema = z20.string().transform((v, ctx) => {
   if (u.username || u.password || u.pathname !== "/" || u.search || u.hash) return bad();
   return u.origin;
 });
-var MobileConfigSchema = z20.object({ enabled: z20.boolean(), relayUrl: RelayUrlSchema });
-var MobileLinkStateSchema = z20.discriminatedUnion("state", [
-  z20.object({ state: z20.literal("off") }),
-  z20.object({ state: z20.literal("connecting") }),
-  z20.object({ state: z20.literal("online") }),
-  z20.object({ state: z20.literal("offline"), retryAt: z20.string().datetime(), error: z20.string() }),
-  z20.object({ state: z20.literal("signed_out"), reason: z20.enum(["other_pc", "session_invalid"]) }),
+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"]) }),
   /** The mobile service did not start (a broken mobile.json, a missing key store): nothing is linked until the daemon restarts. */
-  z20.object({ state: z20.literal("unavailable"), error: z20.string().max(200) })
+  z21.object({ state: z21.literal("unavailable"), error: z21.string().max(200) })
 ]);
-var MobilePairingSchema = z20.object({
-  id: z20.string(),
-  label: z20.string(),
-  code: z20.string().nullable(),
-  expiresAt: z20.string().datetime(),
-  state: z20.enum(["waiting", "confirm", "approved", "linked", "expired", "refused"])
-});
-var MobileStateSchema = z20.object({
-  enabled: z20.boolean(),
-  relayUrl: z20.string(),
-  account: z20.object({ login: z20.string(), accountId: z20.string() }).nullable(),
-  signin: z20.object({ userCode: z20.string(), verificationUri: z20.string(), expiresAt: z20.string().datetime() }).nullable(),
+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(),
   /** The last sign-in that did not end with a session; cleared by the next one. */
-  signinError: z20.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
+  signinError: z21.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
   link: MobileLinkStateSchema,
-  devices: z20.array(z20.object({ id: z20.string(), label: z20.string(), approvedAt: z20.string(), online: z20.boolean(), lastSeenAt: z20.string().optional() })),
-  pairings: z20.array(MobilePairingSchema)
+  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)
 });
 
 // ../protocol/src/messages.ts
-var RefusalCodeSchema = z21.enum(["stale", "read_only", "no_prompt", "not_taken", "busy", "unknown_session", "nothing_to_decide", "not_offered", "free_text", "note_not_typed", "unavailable", "invalid", "attachment_missing", "attachments_not_accepted"]);
-var SessionEventSchema = z21.object({
-  name: z21.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed", "NativeRequest", "AgentMessage", "QueueUpdate"]),
-  at: z21.string().datetime(),
-  source: z21.enum(["hook", "pane", "daemon"]),
-  tool: z21.string().optional(),
-  text: z21.string().optional(),
-  options: z21.array(z21.string()).optional(),
+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(),
   /** Each option's description, by index ('' when it has none); left out when no option has one. */
-  optionDetails: z21.array(z21.string()).optional(),
-  kind: z21.enum(["question", "permission", "plan", "diff"]).optional(),
+  optionDetails: z22.array(z22.string()).optional(),
+  kind: z22.enum(["question", "permission", "plan", "diff"]).optional(),
   /** PanePrompt: what to review in full before deciding (a plan read in the terminal), when `text` is its summary. */
-  body: z21.string().optional(),
-  exitCode: z21.number().int().nullable().optional(),
-  helperId: z21.string().optional(),
+  body: z22.string().optional(),
+  exitCode: z22.number().int().nullable().optional(),
+  helperId: z22.string().optional(),
   /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
-  task: z21.string().optional(),
+  task: z22.string().optional(),
   /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
-  interrupt: z21.boolean().optional(),
+  interrupt: z22.boolean().optional(),
   /** UserPromptSubmit, PostToolUse: the images the prompt or the tool result carried, by attachment id. */
-  attachments: z21.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+  attachments: z22.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
   /** PostToolUse: some of the result's images were not kept. */
-  imagesDropped: z21.boolean().optional(),
+  imagesDropped: z22.boolean().optional(),
   /** QueueUpdate: OMP's queue as it stands. */
-  queue: z21.array(z21.object({ text: z21.string(), mode: z21.enum(["steer", "follow_up"]) })).optional(),
+  queue: z22.array(z22.object({ text: z22.string(), mode: z22.enum(["steer", "follow_up"]) })).optional(),
   /** AgentMessage: the harness's own message, its text so far (`streaming`) or whole. `messageId` is unique for the session's life. */
-  messageId: z21.string().optional(),
-  streaming: z21.boolean().optional(),
+  messageId: z22.string().optional(),
+  streaming: z22.boolean().optional(),
   /** NativeRequest: the dialog's id, and OMP's `ask` questions when it is one. */
-  requestId: z21.string().optional(),
-  questions: z21.array(AskQuestionSchema).optional(),
+  requestId: z22.string().optional(),
+  questions: z22.array(AskQuestionSchema).optional(),
   /** Stop: its text is already in the thread as AgentMessage cards, which the reply card must not repeat. */
-  streamed: z21.boolean().optional(),
+  streamed: z22.boolean().optional(),
   /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
-  toolUseId: z21.string().optional(),
+  toolUseId: z22.string().optional(),
   /** The tool's input as the harness gave it, every string capped by the hook. */
-  toolInput: z21.record(z21.string(), z21.unknown()).optional(),
+  toolInput: z22.record(z22.string(), z22.unknown()).optional(),
   /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
-  output: z21.string().optional(),
-  durationMs: z21.number().nonnegative().optional(),
+  output: z22.string().optional(),
+  durationMs: z22.number().nonnegative().optional(),
   /** PostToolUseFailure: the harness's error message. */
-  error: z21.string().optional(),
+  error: z22.string().optional(),
   /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
-  transcriptPath: z21.string().optional(),
+  transcriptPath: z22.string().optional(),
   /** Decided: what was chosen when the daemon knows it. */
   decision: DecisionSchema.optional(),
   /** Decided: the request was refused by Ledge closing the session (its interrupt keys), not by the user's answer. */
-  byClose: z21.literal(true).optional(),
+  byClose: z22.literal(true).optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
-  agentSessionId: z21.string().optional()
+  agentSessionId: z22.string().optional()
 });
-var RecentSchema = z21.object({ cwd: z21.string().min(1), project: z21.string().min(1), lastAt: z21.string().datetime() });
+var RecentSchema = z22.object({ cwd: z22.string().min(1), project: z22.string().min(1), lastAt: z22.string().datetime() });
 var SEMVER = /^\d+\.\d+\.\d+$/;
-var DaemonInfoSchema = z21.object({
-  version: z21.string(),
-  install: z21.enum(["npm", "git", "unknown"]),
-  systemd: z21.boolean(),
-  manual: z21.string().optional(),
-  routing: z21.boolean().optional(),
-  archive: z21.boolean().optional(),
+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(),
   /** Takes `model` and `effort` on `session.launch` and answers `models.list` (#58). */
-  models: z21.boolean().optional(),
+  models: z22.boolean().optional(),
   /** Drives OMP over its RPC: launching `omp` sessions is possible when the binary is there (`models.list` says so). */
-  omp: z21.boolean().optional(),
+  omp: z22.boolean().optional(),
   /** Takes `session.model`: a live session's model and effort changed (#58, lot 2). */
-  modelSwitch: z21.boolean().optional(),
+  modelSwitch: z22.boolean().optional(),
   /** Takes `approval` on an OMP `session.launch` (auto mode). */
-  ompApproval: z21.boolean().optional(),
+  ompApproval: z22.boolean().optional(),
   /** Its home folder, so a client shows the folders under it as `~` (absent from older daemons). */
-  home: z21.string().optional(),
-  mobile: z21.boolean().optional(),
+  home: z22.string().optional(),
+  mobile: z22.boolean().optional(),
   /** Answers `openrig.status` and `openrig.act`: drives OpenRig on its machine. */
-  openrig: z21.boolean().optional()
+  openrig: z22.boolean().optional(),
+  /** Answers `openrig.roles`, `openrig.role` and `openrig.roleFile`: reads OpenRig's roles (agent specs). */
+  openrigRoles: z22.boolean().optional()
 });
-var UpdateFailureSchema = z21.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
-var ServerMessageSchema = z21.discriminatedUnion("type", [
+var UpdateFailureSchema = z22.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z22.discriminatedUnion("type", [
   SessionModelAcceptedSchema,
-  z21.object({ type: z21.literal("chat.routed"), qid: z21.string(), result: RouteResultSchema }),
+  z22.object({ type: z22.literal("chat.routed"), qid: z22.string(), result: RouteResultSchema }),
   DocumentContentSchema,
   DocumentErrorSchema,
   AttachmentStoredSchema,
@@ -1135,97 +1308,100 @@ var ServerMessageSchema = z21.discriminatedUnion("type", [
   OpenRigSpecListSchema,
   OpenRigLaunchedSchema,
   OpenRigReseatedSchema,
+  OpenRigRoleListSchema,
+  OpenRigRoleDetailSchema,
+  OpenRigRoleFileContentSchema,
   /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
    *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
    *  from daemons older than the auto-update. */
-  z21.object({ type: z21.literal("snapshot"), sessions: z21.array(SessionSchema), recents: z21.array(RecentSchema).optional(), launcher: z21.array(z21.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
-  z21.object({ type: z21.literal("session.updated"), session: SessionSchema }),
+  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 }),
   /** OMP: the instructions taken back from its queue by an interrupt that restores it; the asker puts them back in its draft. */
-  z21.object({
-    type: z21.literal("session.queue.restored"),
-    id: z21.string(),
-    texts: z21.array(z21.string()),
+  z22.object({
+    type: z22.literal("session.queue.restored"),
+    id: z22.string(),
+    texts: z22.array(z22.string()),
     /** The same instructions with the images they carried; `imagesDropped`: some images could not be put back. */
-    entries: z21.array(z21.object({ text: z21.string(), attachments: z21.array(AttachmentIdSchema).optional() })).optional(),
-    imagesDropped: z21.boolean().optional()
+    entries: z22.array(z22.object({ text: z22.string(), attachments: z22.array(AttachmentIdSchema).optional() })).optional(),
+    imagesDropped: z22.boolean().optional()
   }),
-  z21.object({ type: z21.literal("session.removed"), id: z21.string() }),
-  z21.object({ type: z21.literal("session.preview"), id: z21.string(), lines: z21.array(z21.string()) }),
+  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()) }),
   /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
-  z21.object({ type: z21.literal("session.thread"), id: z21.string(), items: z21.array(ThreadItemSchema) }),
-  z21.object({ type: z21.literal("session.thread.item"), id: z21.string(), item: ThreadItemSchema }),
+  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 }),
   /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
-  z21.object({ type: z21.literal("session.launched"), id: z21.string() }),
+  z22.object({ type: z22.literal("session.launched"), id: z22.string() }),
   /** Answer to the requester of a `session.close`, once per row closed: the session `id` and how it ended. */
-  z21.object({ type: z21.literal("session.closed"), qid: z21.string(), row: z21.number().int().min(0), id: z21.string(), how: z21.enum(["exit", "killed"]) }),
-  z21.object({ type: z21.literal("recents"), recents: z21.array(RecentSchema) }),
+  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) }),
   /** Answer to the requester of a `folder.list` or `folder.create`: `path` resolved (`~` expanded), `parent` null at the
    *  root, `entries` its subfolders by name (hidden ones left out). A failure keeps the asked path and says why in `error`,
    *  never in an `error` message, which the launch form reads as a failed launch. */
-  z21.object({
-    type: z21.literal("folder.listing"),
-    path: z21.string(),
-    parent: z21.string().nullable(),
-    entries: z21.array(z21.string()),
-    error: z21.string().optional(),
+  z22.object({
+    type: z22.literal("folder.listing"),
+    path: z22.string(),
+    parent: z22.string().nullable(),
+    entries: z22.array(z22.string()),
+    error: z22.string().optional(),
     /** The request this answers, when it carried one. */
-    requestId: z21.string().optional(),
+    requestId: z22.string().optional(),
     /** Those `entries` that are Git repositories, with their branch (the short commit when HEAD is detached). */
-    repos: z21.array(z21.object({ name: z21.string(), branch: z21.string() })).optional()
+    repos: z22.array(z22.object({ name: z22.string(), branch: z22.string() })).optional()
   }),
   /** The chat (spec 2026-10-11 §5): what Ledge reads, its words as they come, the final text, or why it stopped; the day's turns after each snapshot. */
-  z21.object({ type: z21.literal("chat.step"), qid: z21.string(), step: ChatStepSchema }),
-  z21.object({ type: z21.literal("chat.delta"), qid: z21.string(), text: z21.string() }),
-  z21.object({ type: z21.literal("chat.done"), qid: z21.string(), text: z21.string(), at: z21.string().datetime(), proposal: ChatProposalSchema.optional(), proposals: ChatProposalsSchema.optional(), relay: ChatRelaySchema.optional(), closes: ChatClosesSchema.optional(), projectProposal: ChatProjectProposalSchema.optional(), tasks: ChatTasksSchema.optional(), actions: ChatActionsSchema.optional() }),
+  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() }),
   /** What a `chat.act` applied: the rows done, and the one that failed with why (the rows after it stay proposed). */
-  z21.object({ type: z21.literal("chat.acted"), rid: z21.string(), qid: z21.string(), done: z21.array(z21.number().int().min(0)), failed: z21.array(z21.object({
-    row: z21.number().int().min(0),
-    message: z21.string(),
+  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(),
     /** nothing was sent */
-    refused: z21.literal(true).optional()
+    refused: z22.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). */
-  z21.object({ type: z21.literal("action.result"), rid: z21.string(), action: z21.string().min(1).max(40), row: ChatActionSchema.optional(), reason: z21.string().optional(), code: z21.string().optional() }),
-  z21.object({ type: z21.literal("chat.error"), qid: z21.string(), message: z21.string() }),
-  z21.object({ type: z21.literal("chat.history"), turns: z21.array(ChatTurnSchema) }),
+  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) }),
   /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
-  z21.object({ type: z21.literal("update.progress"), version: z21.string(), step: z21.enum(["installing", "restarting"]) }),
+  z22.object({ type: z22.literal("update.progress"), version: z22.string(), step: z22.enum(["installing", "restarting"]) }),
   /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
-  z21.object({ type: z21.literal("update.failed"), version: z21.string(), reason: UpdateFailureSchema, detail: z21.string().optional(), command: z21.string().optional() }),
+  z22.object({ type: z22.literal("update.failed"), version: z22.string(), reason: UpdateFailureSchema, detail: z22.string().optional(), command: z22.string().optional() }),
   /** The shared machines list (spec 2026-10-14 §5), sent to local clients only. */
-  z21.object({ type: z21.literal("machines"), machines: MachinesSchema }),
+  z22.object({ type: z22.literal("machines"), machines: MachinesSchema }),
   /** The local daemon's projects and folder rules (spec 2026-10-16 build §5), sent to local clients only. */
-  z21.object({ type: z21.literal("projects"), projects: ProjectsSchema }),
+  z22.object({ type: z22.literal("projects"), projects: ProjectsSchema }),
   /** The island's settings shared by the local fronts; null until a front sets them (the island then sends its own). Local clients only. */
-  z21.object({ type: z21.literal("island"), prefs: IslandPrefsSchema.nullable() }),
+  z22.object({ type: z22.literal("island"), prefs: IslandPrefsSchema.nullable() }),
   /** Mobile access (lot 3), after the island in each snapshot and on every change. Local clients only. */
-  z21.object({ type: z21.literal("mobile"), state: MobileStateSchema }),
+  z22.object({ type: z22.literal("mobile"), state: MobileStateSchema }),
   /** The daemon's immediate answer to a `session.message`: delivered (`accepted`), held for later (`queued`), left to Claude's own SendMessage (`native`), or refused with a `reason`. */
-  z21.object({ type: z21.literal("message.ack"), rid: z21.string(), outcome: z21.enum(["accepted", "queued", "native", "refused"]), reason: z21.string().optional() }),
+  z22.object({ type: z22.literal("message.ack"), rid: z22.string(), outcome: z22.enum(["accepted", "queued", "native", "refused"]), reason: z22.string().optional() }),
   /** The answer to a `message.read`: the body with its sender, target and time, or the refusal's `reason`. */
-  z21.object({ type: z21.literal("message.body"), id: z21.string(), from: z21.string().optional(), to: z21.string().optional(), at: z21.string().optional(), text: z21.string().optional(), reason: z21.string().optional() }),
+  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() }),
   TaskResultSchema,
   SessionHandoverResultSchema,
   ContextPrefsMessageSchema,
   HandoverResultSchema,
   TaskUpdatedSchema,
-  z21.object({
-    type: z21.literal("error"),
-    message: z21.string(),
-    id: z21.string().optional(),
+  z22.object({
+    type: z22.literal("error"),
+    message: z22.string(),
+    id: z22.string().optional(),
     /** Le type du message client refusé. */
-    request: z21.string().optional(),
+    request: z22.string().optional(),
     /** Ce que le front doit reconnaître au-delà du texte (NOTE_NOT_TYPED) ; une chaîne libre, qu'un front plus ancien ignore. */
-    code: z21.string().optional()
+    code: z22.string().optional()
   })
 ]);
 var MESSAGE_MAX = 2e4;
 var SUMMARY_MAX = 500;
-var launchRows = z21.array(z21.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
-var ClientMessageSchema = z21.discriminatedUnion("type", [
-  z21.object({ type: z21.literal("chat.route"), qid: z21.string().min(1).max(100), text: z21.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+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 }),
   DocumentReadSchema,
   AttachmentPutSchema,
   AttachmentCaptureSchema,
@@ -1238,155 +1414,158 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
   OpenRigSpecsSchema,
   OpenRigLaunchSchema,
   OpenRigSeatsSchema,
+  OpenRigRolesSchema,
+  OpenRigRoleSchema,
+  OpenRigRoleFileSchema,
   /** The overlay starts a session: `cwd` is a WSL path (`~` allowed), `name` a preferred bot name (the daemon picks a
    *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
    *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields
    *  but `rows`, `model` and `effort`. */
-  z21.object({
-    type: z21.literal("session.launch"),
+  z22.object({
+    type: z22.literal("session.launch"),
     tool: ToolSchema,
-    cwd: z21.string().min(1),
-    name: z21.string().optional(),
-    prompt: z21.string().optional(),
-    continue: z21.boolean().optional(),
-    qid: z21.string().min(1).optional(),
+    cwd: z22.string().min(1),
+    name: z22.string().optional(),
+    prompt: z22.string().optional(),
+    continue: z22.boolean().optional(),
+    qid: z22.string().min(1).optional(),
     /** With `qid`: the card's rows to launch (#24), indexes into the turn's `proposals`, each once; the first row without it. */
     rows: launchRows.optional(),
     /** Folders in addition to `cwd` (Claude: `--add-dir`); resolved like `cwd`. */
-    dirs: z21.array(z21.string().min(1)).max(20).optional(),
+    dirs: z22.array(z22.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: z21.string().optional()
+    machineId: z22.string().optional()
   }),
   /** The launch form's folder browser: list a folder's subfolders (home when no `path`), or make `name` inside `parent`
    *  and list it. Both are answered with a `folder.listing`. */
-  z21.object({
-    type: z21.literal("folder.list"),
-    path: z21.string().optional(),
+  z22.object({
+    type: z22.literal("folder.list"),
+    path: z22.string().optional(),
     /** Routing by the fleet, removed before the message reaches the daemon. */
-    machineId: z21.string().optional(),
+    machineId: z22.string().optional(),
     /** Copied into the `folder.listing` that answers; the fleet relays only that listing, from the machine asked. */
-    requestId: z21.string().min(1).max(100).optional()
+    requestId: z22.string().min(1).max(100).optional()
   }),
-  z21.object({
-    type: z21.literal("folder.create"),
-    parent: z21.string().min(1),
-    name: z21.string().min(1),
+  z22.object({
+    type: z22.literal("folder.create"),
+    parent: z22.string().min(1),
+    name: z22.string().min(1),
     /** As for `folder.list`: routing by the fleet, and the request its `folder.listing` answers. */
-    machineId: z21.string().optional(),
-    requestId: z21.string().min(1).max(100).optional()
+    machineId: z22.string().optional(),
+    requestId: z22.string().min(1).max(100).optional()
   }),
   /** `steer`: OMP only, redirect the turn running now instead of queueing the text after it. */
   /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order (`selected` labels, and/or free `text`); `cancel` declines it. */
-  z21.object({ type: z21.literal("session.answer"), id: z21.string(), requestId: z21.string().min(1).max(200), answers: z21.array(z21.object({ id: z21.string(), selected: z21.array(z21.string().max(2e3)).max(100), text: z21.string().max(2e4).optional() })).max(50), cancel: z21.boolean().optional() }),
-  z21.object({ type: z21.literal("session.reply"), id: z21.string(), text: z21.string(), attachments: z21.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(), steer: z21.boolean().optional() }),
+  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() }),
   /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
-  z21.object({ type: z21.literal("session.relay"), qid: z21.string().min(1) }),
+  z22.object({ type: z22.literal("session.relay"), qid: z22.string().min(1) }),
   /** Takes the card's queued instruction back out of the queue. */
-  z21.object({ type: z21.literal("session.relay.cancel"), qid: z21.string().min(1) }),
+  z22.object({ type: z22.literal("session.relay.cancel"), qid: z22.string().min(1) }),
   /** The chat's generic card (action registry spec §5.1): applies its rows in order (all of them without `rows`), stopping at
    *  the first failure. `confirmed` says the front asked again; refused without it when a row is destructive. */
-  z21.object({
-    type: z21.literal("chat.act"),
-    rid: z21.string().min(1).max(100),
-    qid: z21.string().min(1),
+  z22.object({
+    type: z22.literal("chat.act"),
+    rid: z22.string().min(1).max(100),
+    qid: z22.string().min(1),
     rows: launchRows.optional(),
-    confirmed: z21.literal(true).optional(),
+    confirmed: z22.literal(true).optional(),
     /** « Refuser »: each row (session.decide only) answers its session's request with deny, whatever its own decision; never
      *  confirmed, and allowed on a request shown cut. The rows become `denied`. */
-    deny: z21.literal(true).optional()
+    deny: z22.literal(true).optional()
   }),
   /** « Ignorer » the turn's cards, for every device and for Ledge (who is told at the next question); `undo` opens them
    *  again (« Revoir »). Refused while one of them is under way. Every client gets the turn's `ignoredAt` through chat.history. */
-  z21.object({ type: z21.literal("chat.ignore"), qid: z21.string().min(1), undo: z21.literal(true).optional() }),
+  z22.object({ type: z22.literal("chat.ignore"), qid: z22.string().min(1), undo: z22.literal(true).optional() }),
   /** A registry action run outside the chat (#93, the CLI): the daemon resolves `args` as it does a generic card's row, then
    *  applies it through its own handler. `by` the session that asks, left out for the user; `confirmed` for a destructive one. */
-  z21.object({
-    type: z21.literal("action.run"),
-    rid: z21.string().min(1).max(100),
-    by: z21.string().min(1).optional(),
+  z22.object({
+    type: z22.literal("action.run"),
+    rid: z22.string().min(1).max(100),
+    by: z22.string().min(1).optional(),
     /** `by`'s key (LEDGE_SESSION_KEY) */
-    key: z21.string().max(128).optional(),
+    key: z22.string().max(128).optional(),
     action: ActionIdSchema,
-    args: z21.record(z21.unknown()),
-    confirmed: z21.literal(true).optional()
+    args: z22.record(z22.unknown()),
+    confirmed: z22.literal(true).optional()
   }),
   /** The chat's close card: closes the turn's sessions, `rows` (indexes into its `closes`) or all of them. */
-  z21.object({ type: z21.literal("session.close"), qid: z21.string().min(1), rows: launchRows.optional() }),
+  z22.object({ type: z22.literal("session.close"), qid: z22.string().min(1), rows: launchRows.optional() }),
   /** `always` and `note` only where the harness offers them (`offers`); a note goes with `deny`, for the agent to read. */
-  z21.object({
-    type: z21.literal("session.decide"),
-    id: z21.string(),
+  z22.object({
+    type: z22.literal("session.decide"),
+    id: z22.string(),
     decision: DecisionSchema,
-    note: z21.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z22.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the user saw when deciding: refused (the request changed) unless it is still the pending one. Left out by older fronts and the island.
      *  `key` (pendingKey) covers its whole content; older fronts send kind and text only. */
-    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z21.string().max(64).optional() }).optional()
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z22.string().max(64).optional() }).optional()
   }),
-  z21.object({ type: z21.literal("session.focus"), id: z21.string() }),
-  z21.object({ type: z21.literal("session.kill"), id: z21.string() }),
+  z22.object({ type: z22.literal("session.focus"), id: z22.string() }),
+  z22.object({ type: z22.literal("session.kill"), id: z22.string() }),
   /** `restoreQueue` (OMP): also take back what waits in its queue, returned as `session.queue.restored` to put in the draft. */
-  z21.object({ type: z21.literal("session.interrupt"), id: z21.string(), restoreQueue: z21.boolean().optional() }),
+  z22.object({ type: z22.literal("session.interrupt"), id: z22.string(), restoreQueue: z22.boolean().optional() }),
   /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
-  z21.object({ type: z21.literal("session.dismiss"), id: z21.string() }),
+  z22.object({ type: z22.literal("session.dismiss"), id: z22.string() }),
   /** Puts a session in the archive: it leaves the live list but is kept. */
-  z21.object({ type: z21.literal("session.archive"), id: z21.string() }),
+  z22.object({ type: z22.literal("session.archive"), id: z22.string() }),
   /** Takes an archived session back out of the archive, as it was. */
-  z21.object({ type: z21.literal("session.restore"), id: z21.string() }),
+  z22.object({ type: z22.literal("session.restore"), id: z22.string() }),
   /** Starts the agent again on an archived session's conversation. */
-  z21.object({ type: z21.literal("session.resume"), id: z21.string() }),
+  z22.object({ type: z22.literal("session.resume"), id: z22.string() }),
   /** Changes a live session's model and effort (#58, lot 2), `null` for the agent's own default: the daemon restarts the
    *  agent on the same conversation with them, at once when the session is free, else at its next free moment. */
-  z21.object({ type: z21.literal("session.model"), id: z21.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  z22.object({ type: z22.literal("session.model"), id: z22.string(), model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** Deletes a session for good, archived or not. */
-  z21.object({ type: z21.literal("session.delete"), id: z21.string() }),
+  z22.object({ type: z22.literal("session.delete"), id: z22.string() }),
   /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
-  z21.object({ type: z21.literal("session.rename"), id: z21.string(), topic: z21.string().max(500) }),
-  z21.object({ type: z21.literal("session.thread"), id: z21.string() }),
-  z21.object({ type: z21.literal("session.register"), session: SessionSchema }),
+  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 }),
   /** `agent` and `cwd` describe the session when the daemon does not know it yet (a hook from an agent started without ledge). */
-  z21.object({
-    type: z21.literal("session.event"),
-    id: z21.string(),
+  z22.object({
+    type: z22.literal("session.event"),
+    id: z22.string(),
     event: SessionEventSchema,
     agent: ToolSchema.optional(),
-    cwd: z21.string().optional(),
+    cwd: z22.string().optional(),
     /** The OpenRig seat the agent runs in (`OPENRIG_SESSION_NAME`, `pod-member@rig`), when OpenRig launched it. */
     rigSeat: RigSeatNameSchema.optional()
   }),
-  z21.object({ type: z21.literal("session.unregister"), id: z21.string(), exitCode: z21.number().int().nullable() }),
-  z21.object({ type: z21.literal("snapshot.request") }),
-  z21.object({ type: z21.literal("chat.ask"), qid: z21.string().min(1), text: z21.string(), images: z21.array(ImageUploadSchema).max(ATTACHMENTS_MAX).optional(), tool: ToolSchema.optional() }),
-  z21.object({ type: z21.literal("chat.cancel"), qid: z21.string().min(1) }),
+  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) }),
   /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
-  z21.object({ type: z21.literal("chat.reset") }),
+  z22.object({ type: z22.literal("chat.reset") }),
   /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
-  z21.object({ type: z21.literal("update.daemon"), version: z21.string().regex(SEMVER) }),
+  z22.object({ type: z22.literal("update.daemon"), version: z22.string().regex(SEMVER) }),
   /** Replaces the daemon's machines list (first connected front wins); refused unless valid. */
-  z21.object({ type: z21.literal("machines.set"), machines: MachinesSchema }),
+  z22.object({ type: z22.literal("machines.set"), machines: MachinesSchema }),
   /** Replaces the local daemon's projects and rules as a whole; refused unless valid. */
-  z21.object({ type: z21.literal("projects.set"), projects: ProjectsSchema }),
+  z22.object({ type: z22.literal("projects.set"), projects: ProjectsSchema }),
   /** Replaces the island's settings as a whole; refused unless valid. */
-  z21.object({ type: z21.literal("island.set"), prefs: IslandPrefsSchema }),
+  z22.object({ type: z22.literal("island.set"), prefs: IslandPrefsSchema }),
   /** Mobile access (lot 3), local fronts only. A changed `relayUrl` drops the relay session. */
-  z21.object({ type: z21.literal("mobile.set"), enabled: z21.boolean(), relayUrl: RelayUrlSchema }),
-  z21.object({ type: z21.literal("mobile.signin") }),
-  z21.object({ type: z21.literal("mobile.signin.cancel") }),
-  z21.object({ type: z21.literal("mobile.signout") }),
+  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") }),
   /** While the link is offline: try again now. */
-  z21.object({ type: z21.literal("mobile.retry") }),
-  z21.object({ type: z21.literal("mobile.pairing.approve"), id: z21.string().min(1).max(100) }),
-  z21.object({ type: z21.literal("mobile.pairing.deny"), id: z21.string().min(1).max(100) }),
+  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) }),
   /** `id`: the device's fingerprint. */
-  z21.object({ type: z21.literal("mobile.device.revoke"), id: z21.string().min(1).max(100) }),
+  z22.object({ type: z22.literal("mobile.device.revoke"), id: z22.string().min(1).max(100) }),
   /** One session writing to another by Ledge name (`to` may end in ` [ref]`); `intercept` (the Claude hook): answer `native` unless `to` is a live non-Claude session. */
-  z21.object({ type: z21.literal("session.message"), rid: z21.string().min(1), from: z21.string().min(1), to: z21.string().min(1), text: z21.string().min(1).max(MESSAGE_MAX), summary: z21.string().max(SUMMARY_MAX).optional(), intercept: z21.boolean().optional() }),
+  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() }),
   /** `ledge read <id>`: a message's whole body, for its receiver or its sender (`by`, a session id). */
-  z21.object({ type: z21.literal("message.read"), id: z21.string().min(1).max(40), by: z21.string().min(1) }),
+  z22.object({ type: z22.literal("message.read"), id: z22.string().min(1).max(40), by: z22.string().min(1) }),
   TaskCmdSchema,
   SessionHandoverSchema,
   ContextSetSchema,
@@ -1395,79 +1574,79 @@ var ClientMessageSchema = z21.discriminatedUnion("type", [
 ]);
 
 // ../protocol/src/relay.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var SEALED_MAX = 1048576;
-var RelayPeerSchema = z22.union([z22.literal("pc"), z22.string().regex(/^d_[A-Za-z0-9_-]{16,40}$/)]);
-var RelayClientMessageSchema = z22.object({
-  type: z22.literal("send"),
+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"),
   to: RelayPeerSchema,
-  body: z22.string().max(SEALED_MAX)
+  body: z23.string().max(SEALED_MAX)
 });
-var RelayServerMessageSchema = z22.discriminatedUnion("type", [
-  z22.object({ type: z22.literal("welcome"), accountId: z22.string(), self: RelayPeerSchema, online: z22.array(RelayPeerSchema) }),
-  z22.object({ type: z22.literal("deliver"), from: RelayPeerSchema, body: z22.string() }),
-  z22.object({ type: z22.literal("presence"), peer: RelayPeerSchema, online: z22.boolean() }),
+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() }),
   /**
    * A frame was refused; `to` names the target when it is known.
    * Contract: an error concerning a sealed body (`offline`, `too_large`, or a socket closed with 4008
    * `rate_limited`) means that body was not delivered, so the sequence on that channel is lost: the
    * sender must re-handshake with that peer before sending to it again.
    */
-  z22.object({
-    type: z22.literal("error"),
-    code: z22.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
+  z23.object({
+    type: z23.literal("error"),
+    code: z23.enum(["bad_frame", "too_large", "bad_target", "offline", "rate_limited"]),
     to: RelayPeerSchema.optional()
   })
 ]);
 var PAIR_LABEL_MAX = 40;
-var KeyB64 = z22.string().regex(/^[A-Za-z0-9_-]{87}$/);
-var Nonce = z22.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var Fingerprint = z22.string().regex(/^[A-Za-z0-9_-]{22}$/);
-var SealedFrameSchema = z22.discriminatedUnion("k", [
+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", [
   /** `e` is the ephemeral key, `f` the fingerprint of the sender's static key. */
-  z22.object({ k: z22.literal("hello"), e: KeyB64, f: Fingerprint }),
-  z22.object({ k: z22.literal("msg"), s: z22.string() }),
-  z22.object({ k: z22.literal("pair_commit"), c: Nonce, label: z22.string().trim().min(1).max(PAIR_LABEL_MAX) }),
-  z22.object({ k: z22.literal("pair_offer"), pc: KeyB64, n: Nonce }),
-  z22.object({ k: z22.literal("pair_reveal"), d: KeyB64, n: Nonce }),
-  z22.object({ k: z22.literal("pair_ok") }),
-  z22.object({ k: z22.literal("pair_no") }),
-  z22.object({ k: z22.literal("denied") }),
-  z22.object({ k: z22.literal("rekey") })
+  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") })
 ]);
 
 // ../protocol/src/relayAuth.ts
-import { z as z23 } from "zod";
-var DeviceStartResponseSchema = z23.object({
-  deviceCode: z23.string().min(1),
-  userCode: z23.string().min(1),
-  verificationUri: z23.string().min(1),
-  expiresIn: z23.number().int().positive(),
-  interval: z23.number().int().positive()
-});
-var DevicePollResponseSchema = z23.discriminatedUnion("status", [
-  z23.object({ status: z23.literal("pending") }),
-  z23.object({ status: z23.literal("slow_down"), interval: z23.number().int().positive() }),
+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() }),
   /** `token` is the relay session token, shown this once only. */
-  z23.object({ status: z23.literal("ok"), token: z23.string().min(1), accountId: z23.string().min(1), login: z23.string().min(1) }),
-  z23.object({ status: z23.literal("expired") }),
-  z23.object({ status: z23.literal("denied") }),
-  z23.object({ status: z23.literal("not_allowed") })
+  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") })
 ]);
-var DeviceRevokeResponseSchema = z23.object({ revoked: z23.number().int().min(0) });
-var MeResponseSchema = z23.object({
-  accountId: z23.string().min(1),
-  login: z23.string().min(1),
+var DeviceRevokeResponseSchema = z24.object({ revoked: z24.number().int().min(0) });
+var MeResponseSchema = z24.object({
+  accountId: z24.string().min(1),
+  login: z24.string().min(1),
   peer: RelayPeerSchema,
-  kind: z23.enum(["pc", "device"])
+  kind: z24.enum(["pc", "device"])
 });
 
 // ../protocol/src/phone.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../protocol/src/push.ts
-import { z as z24 } from "zod";
-var B64U = z24.string().regex(/^[A-Za-z0-9_-]*$/);
+import { z as z25 } from "zod";
+var B64U = z25.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;
@@ -1484,29 +1663,29 @@ function pushEndpointAllowed(url) {
     return host.length > suffix.length && host.endsWith(suffix);
   });
 }
-var PushSendSchema = z24.object({
-  endpoint: z24.string().url().max(1024),
+var PushSendSchema = z25.object({
+  endpoint: z25.string().url().max(1024),
   body: B64U.max(5462),
-  ttl: z24.number().int().min(0).max(86400),
-  urgency: z24.enum(["normal", "high"]),
-  topic: z24.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
-});
-var PushSendResultSchema = z24.object({
-  result: z24.enum(["sent", "gone", "failed"]),
-  status: z24.number().int().optional()
-});
-var PushSubscriptionSchema = z24.object({
-  endpoint: z24.string().url().max(1024).refine(pushEndpointAllowed),
-  keys: z24.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
-});
-var PushPayloadSchema = z24.object({
-  v: z24.literal(1),
-  kind: z24.enum(["request", "question", "finished", "chat", "decision"]),
-  title: z24.string().max(80),
-  body: z24.string().max(120),
-  url: z24.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
-  badge: z24.number().int().min(0).max(999),
-  tag: z24.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+  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}$/)
 });
 
 // ../protocol/src/phone.ts
@@ -1516,35 +1695,35 @@ var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var CHECKLIST_TASKS_MAX = 50;
 var CHECKLIST_TEXT_MAX = 200;
-var ChecklistStatusSchema = z25.enum(["pending", "in_progress", "completed"]);
-var PhoneChecklistSchema = z25.object({
-  tasks: z25.array(z25.object({ text: z25.string().max(CHECKLIST_TEXT_MAX), status: ChecklistStatusSchema })).max(CHECKLIST_TASKS_MAX),
-  done: z25.number().int().nonnegative(),
-  total: z25.number().int().nonnegative(),
-  cut: z25.literal(true).optional()
-});
-var PhoneChecklistSummarySchema = z25.object({
-  done: z25.number().int().nonnegative(),
-  total: z25.number().int().nonnegative(),
-  current: z25.string().max(CHECKLIST_TEXT_MAX).optional(),
-  cut: z25.literal(true).optional()
-});
-var RiskSchema = z25.enum(["low", "high"]);
-var RiskReasonSchema = z25.enum(["question", "read_only_command", "edit_inside_folder", "pushes", "destroys", "deploys", "publishes", "pipes_to_shell", "network", "writes_outside_folder", "sensitive_path", "unsafe_flag", "shell_syntax", "script", "plan", "unknown"]);
-var OperationIdSchema = z25.string().uuid();
-var OperationStatusSchema = z25.enum(["received", "applied", "rejected", "failed"]);
-var OperationReasonSchema = z25.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired", "scheduled", ...ModelRefusalSchema.options]);
-var CapabilitiesSchema = z25.object({
+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({
   /** A question can be answered in free text. */
-  freeTextAnswer: z25.boolean(),
+  freeTextAnswer: z26.boolean(),
   /** The session's accept/deny can be typed; absent = true. */
-  decide: z25.boolean().optional(),
+  decide: z26.boolean().optional(),
   /** OMP's dialog questions can be answered from the phone; absent = false. */
-  questions: z25.boolean().optional()
+  questions: z26.boolean().optional()
 });
-var CapabilitiesByToolSchema = z25.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
-var PhonePendingSchema = PendingSchema.extend({ key: z25.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z25.literal(true).optional() });
-var SwitchableSessionSchema = SessionSchema.extend({ canSwitch: z25.literal(true).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 PhoneSessionSchema = SwitchableSessionSchema.pick({
   id: true,
   name: true,
@@ -1572,260 +1751,260 @@ var PhoneSessionSchema = SwitchableSessionSchema.pick({
   exitedAt: true
 }).extend({
   pending: PhonePendingSchema.optional(),
-  unread: z25.boolean(),
-  handover: z25.object({ state: HandoverStateSchema, toName: z25.string().max(80).optional() }).strict().optional(),
+  unread: z26.boolean(),
+  handover: z26.object({ state: HandoverStateSchema, toName: z26.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: z25.literal(true).optional()
+  readOnly: z26.literal(true).optional()
 });
-var B64U2 = z25.string().regex(/^[A-Za-z0-9_-]*$/);
-var CredentialSchema = z25.object({
+var B64U2 = z26.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z26.object({
   id: B64U2.max(1366),
   publicKey: B64U2.max(2048),
-  alg: z25.union([z25.literal(-7), z25.literal(-257)]),
+  alg: z26.union([z26.literal(-7), z26.literal(-257)]),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
-  transports: z25.array(z25.string().max(20)).max(8).optional()
+  transports: z26.array(z26.string().max(20)).max(8).optional()
 });
-var AssertionSchema = z25.object({
+var AssertionSchema = z26.object({
   id: B64U2.max(1366),
   clientDataJSON: B64U2.max(4096),
   authenticatorData: B64U2.max(4096),
   signature: B64U2.max(1024)
 });
-var ConfirmPurposeSchema = z25.enum(["register", "decide", "launch", "close", "act", "pc"]);
+var ConfirmPurposeSchema = z26.enum(["register", "decide", "launch", "close", "act", "pc"]);
 var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
-var PhoneChatProposalSchema = z25.object({
-  project: z25.string().max(80),
+var PhoneChatProposalSchema = z26.object({
+  project: z26.string().max(80),
   tool: ToolSchema,
-  prompt: z25.string().max(TOOL_TEXT_MAX).optional(),
-  launchedId: z25.string().optional(),
-  failed: z25.literal(true).optional()
+  prompt: z26.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z26.string().optional(),
+  failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatRelaySchema = z25.object({
-  id: z25.string().min(1),
-  name: z25.string(),
+var PhoneChatRelaySchema = z26.object({
+  id: z26.string().min(1),
+  name: z26.string(),
   tool: ToolSchema,
-  text: z25.string().max(TOOL_TEXT_MAX),
-  status: z25.enum(["queued", "sent"]).optional(),
-  sentAt: z25.string().datetime().optional(),
-  failed: z25.literal(true).optional(),
+  text: z26.string().max(TOOL_TEXT_MAX),
+  status: z26.enum(["queued", "sent"]).optional(),
+  sentAt: z26.string().datetime().optional(),
+  failed: z26.literal(true).optional(),
   /** With `failed`: why, as the PC's code (never its text). */
-  code: z25.string().max(40).optional()
+  code: z26.string().max(40).optional()
 }).strict();
-var CloseHowSchema = z25.enum(["exit", "killed"]);
-var PhoneChatCloseSchema = z25.object({
-  id: z25.string().min(1),
-  name: z25.string(),
+var CloseHowSchema = z26.enum(["exit", "killed"]);
+var PhoneChatCloseSchema = z26.object({
+  id: z26.string().min(1),
+  name: z26.string(),
   tool: ToolSchema,
   how: CloseHowSchema.optional(),
-  closedAt: z25.string().datetime().optional(),
-  failed: z25.literal(true).optional()
+  closedAt: z26.string().datetime().optional(),
+  failed: z26.literal(true).optional()
 }).strict();
-var PhoneChatTaskSchema = z25.object({
-  to: z25.string().max(80),
-  toName: z25.string().max(80).optional(),
-  title: z25.string().max(200),
-  text: z25.string().max(TOOL_TEXT_MAX).optional(),
-  taskId: z25.string().max(40).optional(),
-  ownerName: z25.string().max(80).optional(),
-  state: z25.enum(["open", "taken", "done", "refused", "dropped"]).optional(),
-  failed: z25.literal(true).optional()
+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()
 }).strict();
-var PhoneChatActionSchema = z25.object({
-  action: z25.string().min(1).max(40),
-  summary: z25.string().max(300),
+var PhoneChatActionSchema = z26.object({
+  action: z26.string().min(1).max(40),
+  summary: z26.string().max(300),
   vars: ActionVarsSchema.optional(),
-  detail: z25.string().max(TOOL_TEXT_MAX).optional(),
-  detailCut: z25.literal(true).optional(),
+  detail: z26.string().max(TOOL_TEXT_MAX).optional(),
+  detailCut: z26.literal(true).optional(),
   risk: ActionRiskSchema,
-  session: z25.string().max(100).optional(),
+  session: z26.string().max(100).optional(),
   state: ChatActionStateSchema.optional(),
-  doneAt: z25.string().datetime().optional(),
-  code: z25.string().max(40).optional()
+  doneAt: z26.string().datetime().optional(),
+  code: z26.string().max(40).optional()
 }).strict();
-var PhoneTaskSchema = z25.object({
-  id: z25.string().max(40),
-  title: z25.string().max(200),
-  owner: z25.string().max(100),
-  ownerName: z25.string().max(80),
+var PhoneTaskSchema = z26.object({
+  id: z26.string().max(40),
+  title: z26.string().max(200),
+  owner: z26.string().max(100),
+  ownerName: z26.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: z25.string().max(100).optional(),
-  giverName: z25.string().max(80).optional(),
-  text: z25.string().max(TOOL_TEXT_MAX).optional(),
-  state: z25.enum(["open", "taken", "done", "refused", "dropped"]),
-  result: z25.string().max(TOOL_TEXT_MAX).optional(),
-  cut: z25.literal(true).optional(),
-  at: z25.string(),
-  updatedAt: z25.string(),
-  seen: z25.literal(true).optional()
+  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()
 }).strict();
-var ChatErrorCodeSchema = z25.enum(["busy", "timeout", "cancelled", "failed"]);
-var PhoneChatTurnSchema = z25.object({
+var ChatErrorCodeSchema = z26.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z26.object({
   qid: OperationIdSchema,
-  question: z25.string().max(MESSAGE_MAX),
-  askedAt: z25.string().datetime(),
-  steps: z25.array(PhoneChatStepSchema).max(50),
-  answer: z25.string().max(THREAD_TEXT_MAX).optional(),
-  answeredAt: z25.string().datetime().optional(),
+  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(),
   error: ChatErrorCodeSchema.optional(),
-  proposals: z25.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  proposals: z26.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
   relay: PhoneChatRelaySchema.optional(),
-  closes: z25.array(PhoneChatCloseSchema).min(1).max(MAX_PROPOSALS).optional(),
-  cut: z25.literal(true).optional(),
-  tasks: z25.array(PhoneChatTaskSchema).min(1).max(MAX_PROPOSALS).optional(),
-  actions: z25.array(PhoneChatActionSchema).min(1).max(MAX_PROPOSALS).optional(),
-  ignoredAt: z25.string().datetime().optional(),
-  attachments: z25.array(AttachmentRefSchema).max(ATTACHMENTS_MAX).optional()
+  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()
 }).strict();
-var sessionId = z25.string().min(1).max(100);
-var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z25.string().min(1).max(64) });
-var CardRowsSchema = z25.array(z25.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice");
+var 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 pcOp = { op: OperationIdSchema, assertion: AssertionSchema.optional() };
-var PcActionSchema = z25.enum(["update", "restart"]);
-var PhoneClientMessageSchema = z25.discriminatedUnion("type", [
-  z25.object({ type: z25.literal("snapshot.request") }),
-  z25.object({ type: z25.literal("session.thread"), id: sessionId }),
+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 }),
   /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
-  z25.object({ type: z25.literal("session.pending"), id: sessionId }),
+  z26.object({ type: z26.literal("session.pending"), id: sessionId }),
   /** The session whose terminal the phone shows; null when it shows none. */
-  z25.object({ type: z25.literal("session.watch"), id: sessionId.nullable() }),
-  z25.object({ type: z25.literal("session.read"), id: sessionId, at: z25.string().datetime() }),
+  z26.object({ type: z26.literal("session.watch"), id: sessionId.nullable() }),
+  z26.object({ type: z26.literal("session.read"), id: sessionId, at: z26.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`).
    */
-  z25.object({
-    type: z25.literal("confirm.prepare"),
+  z26.object({
+    type: z26.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: z25.string().regex(SEMVER).optional()
+    version: z26.string().regex(SEMVER).optional()
   }),
-  z25.object({ type: z25.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
-  z25.object({
-    type: z25.literal("session.decide"),
+  z26.object({ type: z26.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z26.object({
+    type: z26.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z25.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z26.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the phone showed: refused unless it is still the pending one. */
     expect: PhoneExpectSchema,
     /** The device check over the challenge of `confirm.prepare`; required by the daemon for a high-risk accept. */
     assertion: AssertionSchema.optional()
   }),
-  z25.object({
-    type: z25.literal("session.reply"),
+  z26.object({
+    type: z26.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z25.string().max(MESSAGE_MAX),
-    attachments: z25.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
+    text: z26.string().max(MESSAGE_MAX),
+    attachments: z26.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional(),
     /** The request the reply answers, or null when the phone showed none: refused if the session's request is no longer that one. */
     expect: PhoneExpectSchema.nullable(),
     assertion: AssertionSchema.optional()
   }),
   /** OMP's `ask`: the answers to every question of the dialog `requestId`, in order; `cancel` declines it. Bounds as the local `session.answer`. */
-  z25.object({
-    type: z25.literal("session.answer"),
+  z26.object({
+    type: z26.literal("session.answer"),
     op: OperationIdSchema,
     id: sessionId,
-    requestId: z25.string().min(1).max(200),
-    answers: z25.array(z25.object({ id: z25.string().max(200), selected: z25.array(z25.string().max(2e3)).max(100), text: z25.string().max(2e4).optional() })).max(50),
-    cancel: z25.literal(true).optional(),
+    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(),
     expect: PhoneExpectSchema
   }),
-  z25.object({ type: z25.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  z26.object({ type: z26.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. */
-  z25.object({ type: z25.literal("session.close"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
+  z26.object({ type: z26.literal("session.close"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
   /** Starts an ended session again on its conversation. Passkey, purpose `act`, over the session. */
-  z25.object({ type: z25.literal("session.resume"), op: OperationIdSchema, id: sessionId, assertion: AssertionSchema.optional() }),
+  z26.object({ type: z26.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`. */
-  z25.object({ type: z25.literal("session.model"), op: OperationIdSchema, id: sessionId, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
+  z26.object({ type: z26.literal("session.model"), op: OperationIdSchema, id: sessionId, model: ModelIdSchema.nullable(), effort: EffortSchema.nullable() }),
   /** The models an agent offers on the PC. */
-  z25.object({ type: z25.literal("models.list"), tool: ToolSchema }),
+  z26.object({ type: z26.literal("models.list"), tool: ToolSchema }),
   /** The phone drops its passkey from the daemon. */
-  z25.object({ type: z25.literal("device.forget"), op: OperationIdSchema }),
+  z26.object({ type: z26.literal("device.forget"), op: OperationIdSchema }),
   /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z25.object({ type: z25.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
-  z25.object({ type: z25.literal("push.unsubscribe"), op: OperationIdSchema }),
+  z26.object({ type: z26.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z26.object({ type: z26.literal("push.unsubscribe"), op: OperationIdSchema }),
   /** The phone's own chat with Ledge. */
-  z25.object({ type: z25.literal("chat.ask"), qid: OperationIdSchema, text: z25.string().trim().max(MESSAGE_MAX), attachments: z25.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
-  z25.object({ type: z25.literal("chat.cancel"), qid: OperationIdSchema }),
-  z25.object({ type: z25.literal("chat.reset") }),
-  z25.object({ type: z25.literal("chat.history") }),
+  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") }),
   /** An image to store, sent alone before the message that names it; no `id`, and at most `ATTACHMENT_MAX` bytes. */
-  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z25.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
+  AttachmentPutSchema.pick({ type: true, requestId: true }).extend({ image: ImageUploadSchema.extend({ data: z26.string().min(1).max(b64Max(ATTACHMENT_MAX)) }) }),
   AttachmentGetSchema.pick({ type: true, requestId: true, attachment: true, preview: true }),
-  z25.object({ type: z25.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z26.object({ type: z26.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
   /** Takes the card's queued instruction back out of the queue, as the local `session.relay.cancel`. */
-  z25.object({ type: z25.literal("chat.relay.cancel"), op: OperationIdSchema, qid: OperationIdSchema }),
-  z25.object({ type: z25.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
-  z25.object({ type: z25.literal("chat.close"), op: OperationIdSchema, qid: OperationIdSchema, rows: CardRowsSchema.optional(), assertion: AssertionSchema.optional() }),
+  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() }),
   /** A row of the turn's task card: given by Ledge. */
-  z25.object({ type: z25.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z25.number().int().min(0).max(MAX_PROPOSALS - 1) }),
+  z26.object({ type: z26.literal("chat.task"), op: OperationIdSchema, qid: OperationIdSchema, row: z26.number().int().min(0).max(MAX_PROPOSALS - 1) }),
   /** Rows of the turn's generic card (action registry spec §5): `confirmed` as the local `chat.act`; a row whose action asks
    *  for a device check (`phone`) needs one assertion, purpose `act`, over the turn. */
-  z25.object({
-    type: z25.literal("chat.act"),
+  z26.object({
+    type: z26.literal("chat.act"),
     op: OperationIdSchema,
     qid: OperationIdSchema,
     rows: CardRowsSchema.optional(),
-    confirmed: z25.literal(true).optional(),
+    confirmed: z26.literal(true).optional(),
     assertion: AssertionSchema.optional(),
     /** « Refuser », as the local `chat.act`: no passkey, no confirmation. */
-    deny: z25.literal(true).optional()
+    deny: z26.literal(true).optional()
   }),
   /** « Ignorer » the turn's cards, or `undo` (« Revoir »), as the local `chat.ignore`. */
-  z25.object({ type: z25.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z25.literal(true).optional() }),
+  z26.object({ type: z26.literal("chat.ignore"), op: OperationIdSchema, qid: OperationIdSchema, undo: z26.literal(true).optional() }),
   /** Puts a closed task Ledge gave away from « À traiter ». */
-  z25.object({ type: z25.literal("task.seen"), op: OperationIdSchema, task: z25.string().min(1).max(40) }),
+  z26.object({ type: z26.literal("task.seen"), op: OperationIdSchema, task: z26.string().min(1).max(40) }),
   /** Whether the phone's app is in front: a device that is visible gets no push. */
-  z25.object({ type: z25.literal("presence"), visible: z25.boolean() }),
+  z26.object({ type: z26.literal("presence"), visible: z26.boolean() }),
   /** Installs `version` on the PC, then restarts its daemon; the phone asks for its own build's version. Passkey, purpose `pc`. */
-  z25.object({ type: z25.literal("daemon.update"), ...pcOp, version: z25.string().regex(SEMVER) }).strict(),
+  z26.object({ type: z26.literal("daemon.update"), ...pcOp, version: z26.string().regex(SEMVER) }).strict(),
   /** Restarts the PC's daemon without installing anything. Passkey, purpose `pc`. */
-  z25.object({ type: z25.literal("daemon.restart"), ...pcOp }).strict()
+  z26.object({ type: z26.literal("daemon.restart"), ...pcOp }).strict()
 ]);
-var PhoneModelChoiceSchema = z25.object({
+var PhoneModelChoiceSchema = z26.object({
   id: ModelChoiceSchema.shape.id.max(120),
-  label: z25.string().max(80),
-  description: z25.string().max(200).optional(),
-  efforts: z25.array(EffortSchema).max(8).optional(),
+  label: z26.string().max(80),
+  description: z26.string().max(200).optional(),
+  efforts: z26.array(EffortSchema).max(8).optional(),
   defaultEffort: EffortSchema.optional(),
-  isDefault: z25.boolean().optional()
+  isDefault: z26.boolean().optional()
 }).strict();
-var PhoneServerMessageSchema = z25.discriminatedUnion("type", [
-  z25.object({ type: z25.literal("snapshot"), protocol: z25.literal(PHONE_PROTOCOL), sessions: z25.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z25.object({
-    version: z25.string(),
-    name: z25.string().max(40),
-    boot: z25.string().uuid().optional(),
+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(),
     /** The daemon takes `session.model`. */
-    models: z25.literal(true).optional(),
+    models: z26.literal(true).optional(),
     /** The daemon sends `session.checklist` and a session's `checklist` summary. */
-    checklist: z25.literal(true).optional(),
+    checklist: z26.literal(true).optional(),
     /** `update`: the daemon can install a version and restart (npm, systemd); `restart`: it can restart (systemd). */
-    update: z25.literal(true).optional(),
-    restart: z25.literal(true).optional(),
+    update: z26.literal(true).optional(),
+    restart: z26.literal(true).optional(),
     /** The daemon takes `session.close` and `session.resume`. */
-    sessionClose: z25.literal(true).optional()
-  }), device: z25.object({ confirm: z25.boolean(), push: z25.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z25.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
-  z25.object({ type: z25.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z25.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z25.number().int().positive() }),
-  z25.object({ type: z25.literal("session.updated"), session: PhoneSessionSchema }),
-  z25.object({ type: z25.literal("session.removed"), id: z25.string() }),
+    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() }),
   /** A session's checklist, sent to the phone that watches it; `null`: it has none (any more). */
-  z25.object({ type: z25.literal("session.checklist"), id: z25.string(), checklist: PhoneChecklistSchema.nullable() }),
+  z26.object({ type: z26.literal("session.checklist"), id: z26.string(), checklist: PhoneChecklistSchema.nullable() }),
   /** `pending.cut` is set when even this body was shortened. */
-  z25.object({ type: z25.literal("session.pending"), id: z25.string(), pending: PhonePendingSchema }),
-  z25.object({ type: z25.literal("session.preview"), id: z25.string(), lines: z25.array(z25.string()) }),
+  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()) }),
   /** `cut`: the ids of the items shortened; `more`: older items were left out. */
-  z25.object({ type: z25.literal("session.thread"), id: z25.string(), items: z25.array(ThreadItemSchema), cut: z25.array(z25.string()), more: z25.boolean() }),
-  z25.object({ type: z25.literal("session.thread.item"), id: z25.string(), item: ThreadItemSchema, cut: z25.literal(true).optional() }),
-  z25.object({
-    type: z25.literal("operation.result"),
+  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"),
     op: OperationIdSchema,
     status: OperationStatusSchema,
     reason: OperationReasonSchema.optional(),
@@ -1833,27 +2012,27 @@ var PhoneServerMessageSchema = z25.discriminatedUnion("type", [
     how: CloseHowSchema.optional()
   }),
   /** The models an agent offers; `error`: it could not be asked, `models` is then what Ledge knows without it. */
-  z25.object({ type: z25.literal("models.listing"), tool: ToolSchema, models: z25.array(PhoneModelChoiceSchema).max(40), error: z25.literal(true).optional() }),
+  z26.object({ type: z26.literal("models.listing"), tool: ToolSchema, models: z26.array(PhoneModelChoiceSchema).max(40), error: z26.literal(true).optional() }),
   /** A model change that was accepted and then failed (the agent could not restart). */
-  z25.object({ type: z25.literal("session.model.failed"), id: z25.string(), reason: ModelRefusalSchema }),
-  z25.object({ type: z25.literal("chat.history"), turns: z25.array(PhoneChatTurnSchema).max(50) }),
-  z25.object({ type: z25.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  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 }),
   /** The whole text so far, not an increment. */
-  z25.object({ type: z25.literal("chat.delta"), qid: OperationIdSchema, text: z25.string().max(THREAD_TEXT_MAX) }),
-  z25.object({ type: z25.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
-  z25.object({ type: z25.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
+  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 }),
   /** The daemon updating or restarting itself, whoever asked: npm runs, then the service restarts (the link drops right after). */
-  z25.object({ type: z25.literal("daemon.progress"), version: z25.string().max(40), step: z25.enum(["installing", "restarting"]) }),
+  z26.object({ type: z26.literal("daemon.progress"), version: z26.string().max(40), step: z26.enum(["installing", "restarting"]) }),
   /** Nothing was changed. Never npm's output nor a command: both hold the PC's paths. */
-  z25.object({ type: z25.literal("daemon.failed"), version: z25.string().max(40), reason: UpdateFailureSchema }),
+  z26.object({ type: z26.literal("daemon.failed"), version: z26.string().max(40), reason: UpdateFailureSchema }),
   /** The tasks Ledge gave, open or closed lately, after each snapshot; then each change. */
-  z25.object({ type: z25.literal("tasks"), tasks: z25.array(PhoneTaskSchema).max(200) }),
-  z25.object({ type: z25.literal("task.updated"), task: PhoneTaskSchema }),
+  z26.object({ type: z26.literal("tasks"), tasks: z26.array(PhoneTaskSchema).max(200) }),
+  z26.object({ type: z26.literal("task.updated"), task: PhoneTaskSchema }),
   AttachmentStoredSchema,
   AttachmentDataSchema,
   AttachmentErrorSchema,
   /** Never carries free text. */
-  z25.object({ type: z25.literal("error"), code: z25.enum(["invalid", "unknown_session", "too_large"]), request: z25.string().max(40).optional() })
+  z26.object({ type: z26.literal("error"), code: z26.enum(["invalid", "unknown_session", "too_large"]), request: z26.string().max(40).optional() })
 ]);
 
 // src/imageInfo.ts