@paradow/ledge 0.40.0 → 0.42.0

package/dist/cli/reduceWorker.js

@@ -243,6 +243,10 @@ var TaskBlockSchema = z5.object({
 // ../protocol/src/decisions.ts
 import { z as z6 } from "zod";
 var DecisionSchema = z6.enum(["accept", "deny", "always"]);
+var DecidedBySchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("pc") }),
+  z6.object({ kind: z6.literal("device"), id: z6.string().min(1).max(100), name: z6.string().min(1).max(60) })
+]);
 var NOTE_MAX = 4e3;
 
 // ../protocol/src/tasks.ts
@@ -1402,8 +1406,8 @@ var ThreadItemSchema = z22.discriminatedUnion("kind", [
     imagesDropped: z22.literal(true).optional()
   }),
   /** `unknown`: answered in the terminal, the daemon only saw the prompt go away; `always`: allowed and not asked again;
-   *  `byClose`: denied by Ledge closing the session. */
-  z22.object({ kind: z22.literal("permission"), ...base, tool: z22.string(), text: z22.string(), decision: z22.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z22.literal(true).optional() }),
+   *  `byClose`: denied by Ledge closing the session; `by`: who answered it from Ledge (the PC or a device, its name then). */
+  z22.object({ kind: z22.literal("permission"), ...base, tool: z22.string(), text: z22.string(), decision: z22.enum(["accept", "deny", "always", "unknown"]).optional(), byClose: z22.literal(true).optional(), by: DecidedBySchema.optional() }),
   z22.object({ kind: z22.literal("reply"), ...base, text: z22.string() }),
   z22.object({ kind: z22.literal("helper"), ...base, task: z22.string(), agentType: z22.string().optional(), state: z22.enum(["working", "exited"]) }),
   /** A message this session sent to another agent; `id` is the tool_use_id, `to` the address it used, `peer` the Ledge session id, `received` the paired item's id in the peer's thread, `via` set when Ledge's mailbox carries it. */
@@ -1486,6 +1490,9 @@ var MobileLinkStateSchema = z23.discriminatedUnion("state", [
   /** The mobile service did not start (a broken mobile.json, a missing key store): nothing is linked until the daemon restarts. */
   z23.object({ state: z23.literal("unavailable"), error: z23.string().max(200) })
 ]);
+var DeviceKindSchema = z23.enum(["phone", "tablet"]);
+var DEVICE_NAME_MAX = 40;
+var DeviceNameSchema = z23.string().trim().min(1).max(DEVICE_NAME_MAX).regex(/^[^\u0000-\u001f\u007f]+$/);
 var MobilePairingSchema = z23.object({
   id: z23.string(),
   label: z23.string(),
@@ -1501,7 +1508,16 @@ var MobileStateSchema = z23.object({
   /** The last sign-in that did not end with a session; cleared by the next one. */
   signinError: z23.enum(["expired", "denied", "not_allowed", "failed"]).nullable(),
   link: MobileLinkStateSchema,
-  devices: z23.array(z23.object({ id: z23.string(), label: z23.string(), approvedAt: z23.string(), online: z23.boolean(), lastSeenAt: z23.string().optional() })),
+  devices: z23.array(z23.object({
+    id: z23.string(),
+    label: z23.string(),
+    approvedAt: z23.string(),
+    online: z23.boolean(),
+    lastSeenAt: z23.string().optional(),
+    /** Absent from an older daemon; `name` absent: the user gave none, the front derives one from the label. */
+    kind: DeviceKindSchema.optional(),
+    name: z23.string().optional()
+  })),
   pairings: z23.array(MobilePairingSchema),
   /** « Taper dans les terminaux depuis le téléphone »: absent from an older daemon, which has no phone terminal. */
   terminalInput: z23.boolean().optional()
@@ -1556,6 +1572,8 @@ var SessionEventSchema = z24.object({
   decision: DecisionSchema.optional(),
   /** Decided: the request was refused by Ledge closing the session (its interrupt keys), not by the user's answer. */
   byClose: z24.literal(true).optional(),
+  /** Decided: who answered, when the daemon typed it (absent: answered in the terminal, or an older daemon). */
+  by: DecidedBySchema.optional(),
   /** The agent's own session id when the hook names it, so the daemon can resume that conversation. */
   agentSessionId: z24.string().optional()
 });
@@ -1832,7 +1850,9 @@ var ClientMessageSchema = z24.discriminatedUnion("type", [
     note: z24.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the user saw when deciding: refused (the request changed) unless it is still the pending one. Left out by older fronts and the island.
      *  `key` (pendingKey) covers its whole content; older fronts send kind and text only. */
-    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z24.string().max(64).optional() }).optional()
+    expect: PendingSchema.pick({ kind: true, text: true }).extend({ key: z24.string().max(64).optional() }).optional(),
+    /** Who decides: set by the phone gateway for a device (over anything the device sent); left out by a local front, which means the PC. */
+    by: DecidedBySchema.optional()
   }),
   z24.object({ type: z24.literal("session.focus"), id: z24.string() }),
   z24.object({ type: z24.literal("session.kill"), id: z24.string() }),
@@ -1886,10 +1906,13 @@ var ClientMessageSchema = z24.discriminatedUnion("type", [
   z24.object({ type: z24.literal("mobile.signout") }),
   /** While the link is offline: try again now. */
   z24.object({ type: z24.literal("mobile.retry") }),
-  z24.object({ type: z24.literal("mobile.pairing.approve"), id: z24.string().min(1).max(100) }),
+  /** `replaces`: an approved device this one takes the place of (the same app reinstalled), revoked once this one is stored. */
+  z24.object({ type: z24.literal("mobile.pairing.approve"), id: z24.string().min(1).max(100), replaces: z24.string().min(1).max(100).optional() }),
   z24.object({ type: z24.literal("mobile.pairing.deny"), id: z24.string().min(1).max(100) }),
   /** `id`: the device's fingerprint. */
   z24.object({ type: z24.literal("mobile.device.revoke"), id: z24.string().min(1).max(100) }),
+  /** Names a device (`id`: its fingerprint); the device sees its new name in its next snapshot. */
+  z24.object({ type: z24.literal("mobile.device.rename"), id: z24.string().min(1).max(100), name: DeviceNameSchema }),
   /** « Taper dans les terminaux depuis le téléphone »; turned off, every phone loses the hand. */
   z24.object({ type: z24.literal("mobile.terminal"), input: z24.boolean() }),
   /** « Reprendre la main »: the phone typing into the session's terminal goes back to reading it. */
@@ -2022,7 +2045,9 @@ var PushSubscriptionSchema = z27.object({
 });
 var PushPayloadSchema = z27.object({
   v: z27.literal(1),
-  kind: z27.enum(["request", "question", "finished", "chat", "decision"]),
+  /** `resolved`: a request or question answered (anywhere), replacing its notification under the same tag; only sent to a
+   *  device whose subscription says its service worker knows it (`push.subscribe` `resolved`). */
+  kind: z27.enum(["request", "question", "finished", "chat", "decision", "resolved"]),
   title: z27.string().max(80),
   body: z27.string().max(120),
   url: z27.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
@@ -2289,8 +2314,11 @@ var PhoneClientMessageSchema = z28.discriminatedUnion("type", [
   z28.object({ type: z28.literal("openrig.row"), qitem: QitemIdSchema }),
   /** The phone drops its passkey from the daemon. */
   z28.object({ type: z28.literal("device.forget"), op: OperationIdSchema }),
-  /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
-  z28.object({ type: z28.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  /** The device names itself (on the PC and in its next snapshot); applied to the sender only. */
+  z28.object({ type: z28.literal("device.rename"), op: OperationIdSchema, name: DeviceNameSchema }),
+  /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). `resolved`: its service
+   *  worker shows a `resolved` push, which replaces a request's notification once it is answered elsewhere. */
+  z28.object({ type: z28.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87), resolved: z28.literal(true).optional() }),
   z28.object({ type: z28.literal("push.unsubscribe"), op: OperationIdSchema }),
   /** The phone's own chat with Ledge. */
   z28.object({ type: z28.literal("chat.ask"), qid: OperationIdSchema, text: z28.string().trim().max(MESSAGE_MAX), attachments: z28.array(AttachmentIdSchema).max(ATTACHMENTS_MAX).optional() }),
@@ -2382,7 +2410,16 @@ var PhoneServerMessageSchema = z28.discriminatedUnion("type", [
     openrig: z28.literal(true).optional(),
     /** The daemon takes `session.broadcast` (« Écrire au groupe »). */
     broadcast: z28.literal(true).optional()
-  }), device: z28.object({ confirm: z28.boolean(), push: z28.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z28.literal(true).optional(), contextNear: ContextPrefsSchema.shape.near.optional() }).optional() }),
+  }), device: z28.object({
+    confirm: z28.boolean(),
+    push: z28.enum(["on", "off", "stale", "unavailable"]).optional(),
+    chat: z28.literal(true).optional(),
+    contextNear: ContextPrefsSchema.shape.near.optional(),
+    /** This device's id (its fingerprint, as decisions name it in `by`), its kind, and the name the user gave it (absent: none given). */
+    id: z28.string().optional(),
+    kind: DeviceKindSchema.optional(),
+    name: z28.string().optional()
+  }).optional() }),
   /** « À toi » on this PC: the answer to `openrig.asks`, then each change, whole. */
   z28.object({ type: z28.literal("openrig.asks"), channel: HumanChannelSchema, asks: z28.array(HumanAskSchema), partial: z28.literal(true).optional(), truncated: z28.literal(true).optional() }),
   /** An answer's end, as on the desktop (`openrig.answered`), under the phone's `op`. `rejected`: the device check refused it (`reason`). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paradow/ledge",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "description": "Follow and answer your WSL agent sessions (Claude Code, Codex, Cursor Agent) from the Ledge island on Windows.",
   "type": "module",
   "bin": { "ledge": "dist/cli/index.js" },