@paradow/ledge 0.14.0 → 0.15.1

package/README.md

@@ -30,7 +30,7 @@ pnpm --filter @paradow/ledge build
 chmod +x packages/ledge/dist/cli/index.js
 mkdir -p ~/.local/bin
 ln -sf "$PWD/packages/ledge/dist/cli/index.js" ~/.local/bin/ledge   # ~/.local/bin must be on the PATH Claude Code uses for hooks
-ledge setup
+ledge setup                         # the link becomes a script that runs the CLI with this node (a session Ledge launches may have no node on its PATH: nvm)
 ```
 
 The daemon is spawned from the built CLI (`dist/cli/index.js`), so rebuild after changes (`pnpm --filter @paradow/ledge build`).
@@ -43,7 +43,7 @@ ledge claude --name max # pick the bot's name
 ledge status            # list bots and what they wait for
 ledge attach <id>       # put this terminal on a running session (what the overlay opens a tab with)
 ledge daemon            # run the daemon in the foreground (normally run by the systemd service)
-ledge uninstall         # undo ledge setup: hooks, service and the ~/.local/bin link (--purge: ~/.ledge too)
+ledge uninstall         # undo ledge setup: hooks, service and ~/.local/bin/ledge (--purge: ~/.ledge too)
 ```
 
 `ledge setup` installs `ledge-daemon.service` as a systemd user unit, starts it and enables linger, so the daemon runs from WSL boot and restarts after a crash. Rerun it after a node upgrade or a repository move: the unit is rewritten and the service restarted. Useful commands:

package/dist/cli/{attach-3U4A44ZE.js → attach-Y4OMZXAH.js}

@@ -1,19 +1,19 @@
 import {
   attachEnv
-} from "./chunk-D3JQV5AA.js";
+} from "./chunk-4IBQ4PG6.js";
 import {
   connect
-} from "./chunk-PFDZ6VYG.js";
-import "./chunk-ULWVO3TH.js";
+} from "./chunk-PXO4FFJR.js";
+import "./chunk-KGEF6OIU.js";
 import {
   PROTOCOL_PORT,
   backendOf
-} from "./chunk-5LVPB3ET.js";
+} from "./chunk-2LQITRTR.js";
 import {
   realTmux
-} from "./chunk-FPW7MF5X.js";
-import "./chunk-5DDBCJX2.js";
-import "./chunk-QBJEUZYW.js";
+} from "./chunk-2H5FJH4Q.js";
+import "./chunk-BNKPXSUY.js";
+import "./chunk-R5462SQM.js";
 
 // src/cli/attach.ts
 import { spawn } from "child_process";

package/dist/cli/{bridge-7JT6P53L.js → bridge-6K523KUX.js}

@@ -7,8 +7,8 @@ import {
   parseClientMessage,
   parseServerMessage,
   readDaemonToken
-} from "./chunk-5LVPB3ET.js";
-import "./chunk-QBJEUZYW.js";
+} from "./chunk-2LQITRTR.js";
+import "./chunk-R5462SQM.js";
 
 // src/cli/bridge.ts
 import WebSocket from "ws";

package/dist/cli/{chunk-FPW7MF5X.js → chunk-2H5FJH4Q.js}

@@ -1,9 +1,9 @@
 import {
   log
-} from "./chunk-5DDBCJX2.js";
+} from "./chunk-BNKPXSUY.js";
 import {
   paths
-} from "./chunk-QBJEUZYW.js";
+} from "./chunk-R5462SQM.js";
 
 // src/tmux.ts
 import { execFile } from "child_process";

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

@@ -1,6 +1,6 @@
 import {
   paths
-} from "./chunk-QBJEUZYW.js";
+} from "./chunk-R5462SQM.js";
 
 // ../protocol/src/session.ts
 import { z } from "zod";
@@ -458,7 +458,7 @@ function pendingKey(p) {
 
 // ../protocol/src/mobile.ts
 import { z as z14 } from "zod";
-var DEFAULT_RELAY_URL = "https://server.ledge.paradow.dev";
+var DEFAULT_RELAY_URL = "https://app.kl-ledge.dev";
 var RelayUrlSchema = z14.string().transform((v, ctx) => {
   const bad = () => {
     ctx.addIssue({ code: z14.ZodIssueCode.custom, message: "invalid relay URL" });
@@ -973,7 +973,53 @@ var MeResponseSchema = z18.object({
 });
 
 // ../protocol/src/phone.ts
+import { z as z20 } from "zod";
+
+// ../protocol/src/push.ts
 import { z as z19 } from "zod";
+var B64U = z19.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;
+  try {
+    u = new URL(url);
+  } catch {
+    return false;
+  }
+  if (u.protocol !== "https:" || u.port !== "" || u.username !== "" || u.password !== "") return false;
+  const host = u.hostname.toLowerCase();
+  return PUSH_HOSTS.some((h) => {
+    if (!h.startsWith("*.")) return host === h;
+    const suffix = h.slice(1);
+    return host.length > suffix.length && host.endsWith(suffix);
+  });
+}
+var PushSendSchema = z19.object({
+  endpoint: z19.string().url().max(1024),
+  body: B64U.max(5462),
+  ttl: z19.number().int().min(0).max(86400),
+  urgency: z19.enum(["normal", "high"]),
+  topic: z19.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+});
+var PushSendResultSchema = z19.object({
+  result: z19.enum(["sent", "gone", "failed"]),
+  status: z19.number().int().optional()
+});
+var PushSubscriptionSchema = z19.object({
+  endpoint: z19.string().url().max(1024).refine(pushEndpointAllowed),
+  keys: z19.object({ p256dh: B64U.length(87), auth: B64U.length(22) })
+});
+var PushPayloadSchema = z19.object({
+  v: z19.literal(1),
+  kind: z19.enum(["request", "question", "finished", "chat"]),
+  title: z19.string().max(80),
+  body: z19.string().max(120),
+  url: z19.string().regex(/^\/#\/[A-Za-z0-9/%._~-]*$/).max(300),
+  badge: z19.number().int().min(0).max(999),
+  tag: z19.string().regex(/^[A-Za-z0-9_-]{1,32}$/)
+});
+
+// ../protocol/src/phone.ts
 var PHONE_PROTOCOL = 1;
 var PAD_TIERS = [1024, 4096, 16384, 65536, 262144, 655360];
 var PLAIN_MAX = 655360;
@@ -991,18 +1037,22 @@ var THREAD_TEXT_MAX = 8192;
 var TOOL_TEXT_MAX = 2048;
 var PENDING_BODY_MAX = 65536;
 var SNAPSHOT_BODY_MAX = 2048;
-var RiskSchema = z19.enum(["low", "high"]);
-var RiskReasonSchema = z19.enum(["question", "read_only_command", "edit_inside_folder", "pushes", "destroys", "deploys", "publishes", "pipes_to_shell", "network", "writes_outside_folder", "sensitive_path", "unsafe_flag", "shell_syntax", "script", "plan", "unknown"]);
-var OperationIdSchema = z19.string().uuid();
-var OperationStatusSchema = z19.enum(["received", "applied", "rejected", "failed"]);
-var OperationReasonSchema = z19.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict"]);
-var CapabilitiesSchema = z19.object({
+var RiskSchema = z20.enum(["low", "high"]);
+var RiskReasonSchema = z20.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 = z20.string().uuid();
+var OperationStatusSchema = z20.enum(["received", "applied", "rejected", "failed"]);
+var OperationReasonSchema = z20.enum([...RefusalCodeSchema.options, "untypable", "confirm_required", "conflict", "assertion_invalid", "assertion_expired"]);
+var CapabilitiesSchema = z20.object({
   /** A question can be answered in free text. */
-  freeTextAnswer: z19.boolean()
+  freeTextAnswer: z20.boolean(),
+  /** The session's accept/deny can be typed; absent = true. */
+  decide: z20.boolean().optional(),
+  /** OMP's dialog questions can be answered from the phone; absent = false. */
+  questions: z20.boolean().optional()
 });
 var UNTYPABLE = /[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u2028-\u202e\u2066-\u2069\ufeff]/;
-var CapabilitiesByToolSchema = z19.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
-var PhonePendingSchema = PendingSchema.extend({ key: z19.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z19.literal(true).optional() });
+var CapabilitiesByToolSchema = z20.object({ claude: CapabilitiesSchema, codex: CapabilitiesSchema, cursor: CapabilitiesSchema, omp: CapabilitiesSchema });
+var PhonePendingSchema = PendingSchema.extend({ key: z20.string().max(64), risk: RiskSchema, riskReason: RiskReasonSchema, cut: z20.literal(true).optional() });
 var PhoneSessionSchema = SessionSchema.pick({
   id: true,
   name: true,
@@ -1018,49 +1068,133 @@ var PhoneSessionSchema = SessionSchema.pick({
   lastReply: true,
   startedAt: true,
   lastActivityAt: true
-}).extend({ pending: PhonePendingSchema.optional(), unread: z19.boolean() });
-var sessionId = z19.string().min(1).max(100);
-var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z19.string().min(1).max(64) });
-var PhoneClientMessageSchema = z19.discriminatedUnion("type", [
-  z19.object({ type: z19.literal("snapshot.request") }),
-  z19.object({ type: z19.literal("session.thread"), id: sessionId }),
+}).extend({ pending: PhonePendingSchema.optional(), unread: z20.boolean() });
+var B64U2 = z20.string().regex(/^[A-Za-z0-9_-]*$/);
+var CredentialSchema = z20.object({
+  id: B64U2.max(1366),
+  publicKey: B64U2.max(2048),
+  alg: z20.union([z20.literal(-7), z20.literal(-257)]),
+  clientDataJSON: B64U2.max(4096),
+  authenticatorData: B64U2.max(4096),
+  transports: z20.array(z20.string().max(20)).max(8).optional()
+});
+var AssertionSchema = z20.object({
+  id: B64U2.max(1366),
+  clientDataJSON: B64U2.max(4096),
+  authenticatorData: B64U2.max(4096),
+  signature: B64U2.max(1024)
+});
+var ConfirmPurposeSchema = z20.enum(["register", "decide", "launch"]);
+var PhoneChatStepSchema = ChatStepSchema.pick({ kind: true, id: true, name: true }).strict();
+var PhoneChatProposalSchema = z20.object({
+  project: z20.string().max(80),
+  tool: ToolSchema,
+  prompt: z20.string().max(TOOL_TEXT_MAX).optional(),
+  launchedId: z20.string().optional(),
+  failed: z20.literal(true).optional()
+}).strict();
+var PhoneChatRelaySchema = z20.object({
+  id: z20.string().min(1),
+  name: z20.string(),
+  tool: ToolSchema,
+  text: z20.string().max(TOOL_TEXT_MAX),
+  status: z20.enum(["queued", "sent"]).optional(),
+  sentAt: z20.string().datetime().optional(),
+  failed: z20.literal(true).optional()
+}).strict();
+var ChatErrorCodeSchema = z20.enum(["busy", "timeout", "cancelled", "failed"]);
+var PhoneChatTurnSchema = z20.object({
+  qid: OperationIdSchema,
+  question: z20.string().max(MESSAGE_MAX),
+  askedAt: z20.string().datetime(),
+  steps: z20.array(PhoneChatStepSchema).max(50),
+  answer: z20.string().max(THREAD_TEXT_MAX).optional(),
+  answeredAt: z20.string().datetime().optional(),
+  error: ChatErrorCodeSchema.optional(),
+  proposals: z20.array(PhoneChatProposalSchema).max(MAX_PROPOSALS).optional(),
+  relay: PhoneChatRelaySchema.optional(),
+  cut: z20.literal(true).optional()
+}).strict();
+var CHAT_HISTORY_BUDGET = 393216;
+var sessionId = z20.string().min(1).max(100);
+var PhoneExpectSchema = PendingSchema.pick({ kind: true, text: true }).extend({ key: z20.string().min(1).max(64) });
+var PhoneClientMessageSchema = z20.discriminatedUnion("type", [
+  z20.object({ type: z20.literal("snapshot.request") }),
+  z20.object({ type: z20.literal("session.thread"), id: sessionId }),
   /** The session's request with its whole body (up to `PENDING_BODY_MAX`). */
-  z19.object({ type: z19.literal("session.pending"), id: sessionId }),
+  z20.object({ type: z20.literal("session.pending"), id: sessionId }),
   /** The session whose terminal the phone shows; null when it shows none. */
-  z19.object({ type: z19.literal("session.watch"), id: sessionId.nullable() }),
-  z19.object({ type: z19.literal("session.read"), id: sessionId, at: z19.string().datetime() }),
-  z19.object({
-    type: z19.literal("session.decide"),
+  z20.object({ type: z20.literal("session.watch"), id: sessionId.nullable() }),
+  z20.object({ type: z20.literal("session.read"), id: sessionId, at: z20.string().datetime() }),
+  /** Asks for a challenge. One object for both purposes: the gateway refuses a `decide` without `id` and `expect`. */
+  z20.object({ type: z20.literal("confirm.prepare"), purpose: ConfirmPurposeSchema, id: sessionId.optional(), expect: PhoneExpectSchema.optional(), qid: OperationIdSchema.optional() }),
+  z20.object({ type: z20.literal("credential.register"), op: OperationIdSchema, credential: CredentialSchema }),
+  z20.object({
+    type: z20.literal("session.decide"),
     op: OperationIdSchema,
     id: sessionId,
     decision: DecisionSchema,
-    note: z19.string().trim().min(1).max(NOTE_MAX).optional(),
+    note: z20.string().trim().min(1).max(NOTE_MAX).optional(),
     /** The request the phone showed: refused unless it is still the pending one. */
-    expect: PhoneExpectSchema
+    expect: PhoneExpectSchema,
+    /** The device check over the challenge of `confirm.prepare`; required by the daemon for a high-risk accept. */
+    assertion: AssertionSchema.optional()
   }),
-  z19.object({
-    type: z19.literal("session.reply"),
+  z20.object({
+    type: z20.literal("session.reply"),
     op: OperationIdSchema,
     id: sessionId,
-    text: z19.string().min(1).max(MESSAGE_MAX),
+    text: z20.string().min(1).max(MESSAGE_MAX),
     /** The request the reply answers, or null when the phone showed none: refused if the session's request is no longer that one. */
-    expect: PhoneExpectSchema.nullable()
+    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`. */
+  z20.object({
+    type: z20.literal("session.answer"),
+    op: OperationIdSchema,
+    id: sessionId,
+    requestId: z20.string().min(1).max(200),
+    answers: z20.array(z20.object({ id: z20.string().max(200), selected: z20.array(z20.string().max(2e3)).max(100), text: z20.string().max(2e4).optional() })).max(50),
+    cancel: z20.literal(true).optional(),
+    expect: PhoneExpectSchema
   }),
-  z19.object({ type: z19.literal("session.interrupt"), op: OperationIdSchema, id: sessionId })
+  z20.object({ type: z20.literal("session.interrupt"), op: OperationIdSchema, id: sessionId }),
+  /** The phone drops its passkey from the daemon. */
+  z20.object({ type: z20.literal("device.forget"), op: OperationIdSchema }),
+  /** The phone's push subscription, with the VAPID key it was made with (so a key change is seen). */
+  z20.object({ type: z20.literal("push.subscribe"), op: OperationIdSchema, subscription: PushSubscriptionSchema, key: B64U2.length(87) }),
+  z20.object({ type: z20.literal("push.unsubscribe"), op: OperationIdSchema }),
+  /** The phone's own chat with Ledge. */
+  z20.object({ type: z20.literal("chat.ask"), qid: OperationIdSchema, text: z20.string().trim().min(1).max(MESSAGE_MAX) }),
+  z20.object({ type: z20.literal("chat.cancel"), qid: OperationIdSchema }),
+  z20.object({ type: z20.literal("chat.reset") }),
+  z20.object({ type: z20.literal("chat.history") }),
+  z20.object({ type: z20.literal("chat.relay"), op: OperationIdSchema, qid: OperationIdSchema }),
+  z20.object({ type: z20.literal("chat.launch"), op: OperationIdSchema, qid: OperationIdSchema, rows: z20.array(z20.number().int().min(0).max(MAX_PROPOSALS - 1)).min(1).max(MAX_PROPOSALS).refine((r) => new Set(r).size === r.length, "a row twice").optional(), assertion: AssertionSchema.optional() }),
+  /** Whether the phone's app is in front: a device that is visible gets no push. */
+  z20.object({ type: z20.literal("presence"), visible: z20.boolean() })
 ]);
-var PhoneServerMessageSchema = z19.discriminatedUnion("type", [
-  z19.object({ type: z19.literal("snapshot"), protocol: z19.literal(PHONE_PROTOCOL), sessions: z19.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z19.object({ version: z19.string(), name: z19.string().max(40) }) }),
-  z19.object({ type: z19.literal("session.updated"), session: PhoneSessionSchema }),
-  z19.object({ type: z19.literal("session.removed"), id: z19.string() }),
+var PhoneServerMessageSchema = z20.discriminatedUnion("type", [
+  z20.object({ type: z20.literal("snapshot"), protocol: z20.literal(PHONE_PROTOCOL), sessions: z20.array(PhoneSessionSchema), capabilities: CapabilitiesByToolSchema, daemon: z20.object({ version: z20.string(), name: z20.string().max(40), boot: z20.string().uuid().optional() }), device: z20.object({ confirm: z20.boolean(), push: z20.enum(["on", "off", "stale", "unavailable"]).optional(), chat: z20.literal(true).optional() }).optional() }),
+  z20.object({ type: z20.literal("confirm.challenge"), purpose: ConfirmPurposeSchema, challenge: B64U2.max(64), rpId: z20.string().max(253), credentialId: B64U2.max(1366).optional(), expiresInMs: z20.number().int().positive() }),
+  z20.object({ type: z20.literal("session.updated"), session: PhoneSessionSchema }),
+  z20.object({ type: z20.literal("session.removed"), id: z20.string() }),
   /** `pending.cut` is set when even this body was shortened. */
-  z19.object({ type: z19.literal("session.pending"), id: z19.string(), pending: PhonePendingSchema }),
-  z19.object({ type: z19.literal("session.preview"), id: z19.string(), lines: z19.array(z19.string()) }),
+  z20.object({ type: z20.literal("session.pending"), id: z20.string(), pending: PhonePendingSchema }),
+  z20.object({ type: z20.literal("session.preview"), id: z20.string(), lines: z20.array(z20.string()) }),
   /** `cut`: the ids of the items shortened; `more`: older items were left out. */
-  z19.object({ type: z19.literal("session.thread"), id: z19.string(), items: z19.array(ThreadItemSchema), cut: z19.array(z19.string()), more: z19.boolean() }),
-  z19.object({ type: z19.literal("session.thread.item"), id: z19.string(), item: ThreadItemSchema, cut: z19.literal(true).optional() }),
-  z19.object({ type: z19.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
+  z20.object({ type: z20.literal("session.thread"), id: z20.string(), items: z20.array(ThreadItemSchema), cut: z20.array(z20.string()), more: z20.boolean() }),
+  z20.object({ type: z20.literal("session.thread.item"), id: z20.string(), item: ThreadItemSchema, cut: z20.literal(true).optional() }),
+  z20.object({ type: z20.literal("operation.result"), op: OperationIdSchema, status: OperationStatusSchema, reason: OperationReasonSchema.optional() }),
+  z20.object({ type: z20.literal("chat.history"), turns: z20.array(PhoneChatTurnSchema).max(50) }),
+  z20.object({ type: z20.literal("chat.step"), qid: OperationIdSchema, step: PhoneChatStepSchema }),
+  /** The whole text so far, not an increment. */
+  z20.object({ type: z20.literal("chat.delta"), qid: OperationIdSchema, text: z20.string().max(THREAD_TEXT_MAX) }),
+  z20.object({ type: z20.literal("chat.done"), qid: OperationIdSchema, turn: PhoneChatTurnSchema }),
+  z20.object({ type: z20.literal("chat.error"), qid: OperationIdSchema, code: ChatErrorCodeSchema }),
   /** Never carries free text. */
-  z19.object({ type: z19.literal("error"), code: z19.enum(["invalid", "unknown_session", "too_large"]), request: z19.string().max(40).optional() })
+  z20.object({ type: z20.literal("error"), code: z20.enum(["invalid", "unknown_session", "too_large"]), request: z20.string().max(40).optional() })
 ]);
 
 // src/auth.ts
@@ -1225,6 +1359,9 @@ export {
   RELAY_CLOSE_SIGNED_OUT,
   DeviceStartResponseSchema,
   DevicePollResponseSchema,
+  pushEndpointAllowed,
+  PushSendResultSchema,
+  PushPayloadSchema,
   PHONE_PROTOCOL,
   padPlain,
   THREAD_ITEMS_MAX,
@@ -1233,7 +1370,9 @@ export {
   TOOL_TEXT_MAX,
   PENDING_BODY_MAX,
   SNAPSHOT_BODY_MAX,
+  OperationIdSchema,
   UNTYPABLE,
+  CHAT_HISTORY_BUDGET,
   PhoneClientMessageSchema,
   hostAllowed,
   requestAuthorized,

package/dist/cli/{chunk-D3JQV5AA.js → chunk-4IBQ4PG6.js}

@@ -1,23 +1,23 @@
 import {
   DaemonRefusedError,
   connect
-} from "./chunk-PFDZ6VYG.js";
+} from "./chunk-PXO4FFJR.js";
 import {
   exitFile,
   spawnSession
-} from "./chunk-ULWVO3TH.js";
+} from "./chunk-KGEF6OIU.js";
 import {
   PROTOCOL_PORT
-} from "./chunk-5LVPB3ET.js";
+} from "./chunk-2LQITRTR.js";
 import {
   realTmux
-} from "./chunk-FPW7MF5X.js";
+} from "./chunk-2H5FJH4Q.js";
 import {
   log
-} from "./chunk-5DDBCJX2.js";
+} from "./chunk-BNKPXSUY.js";
 import {
   ensureLedgeDir
-} from "./chunk-QBJEUZYW.js";
+} from "./chunk-R5462SQM.js";
 
 // src/cli/launch.ts
 import { spawn } from "child_process";

package/dist/cli/{chunk-5DDBCJX2.js → chunk-BNKPXSUY.js}

@@ -1,6 +1,6 @@
 import {
   paths
-} from "./chunk-QBJEUZYW.js";
+} from "./chunk-R5462SQM.js";
 
 // src/log.ts
 import { appendFileSync } from "fs";

package/dist/cli/{chunk-2P2SUT7A.js → chunk-IMSPQUFC.js}

@@ -1,10 +1,10 @@
 import {
   connect,
   sendMessageAndAwaitAck
-} from "./chunk-PFDZ6VYG.js";
+} from "./chunk-PXO4FFJR.js";
 import {
   CODEX_HOOK_VAR
-} from "./chunk-ULWVO3TH.js";
+} from "./chunk-KGEF6OIU.js";
 
 // src/cli/send.ts
 import { randomUUID } from "crypto";

package/dist/cli/{chunk-ULWVO3TH.js → chunk-KGEF6OIU.js}

@@ -1,9 +1,9 @@
 import {
   pickName
-} from "./chunk-5LVPB3ET.js";
+} from "./chunk-2LQITRTR.js";
 import {
   paths
-} from "./chunk-QBJEUZYW.js";
+} from "./chunk-R5462SQM.js";
 
 // src/daemon/transcript.ts
 import { closeSync, fstatSync, openSync, readSync } from "fs";

package/dist/cli/chunk-LKQ5DDQ4.js

@@ -0,0 +1,6 @@
+// src/version.ts
+var LEDGE_VERSION = true ? "0.15.1" : "0.0.0-dev";
+
+export {
+  LEDGE_VERSION
+};

package/dist/cli/{chunk-IIXALRFM.js → chunk-NKYJF3VT.js}

@@ -1,9 +1,9 @@
 import {
   connect
-} from "./chunk-PFDZ6VYG.js";
+} from "./chunk-PXO4FFJR.js";
 import {
   isArchived
-} from "./chunk-5LVPB3ET.js";
+} from "./chunk-2LQITRTR.js";
 
 // src/cli/who.ts
 import { basename } from "path";

package/dist/cli/{chunk-PFDZ6VYG.js → chunk-PXO4FFJR.js}

@@ -4,7 +4,7 @@ import {
   SUMMARY_MAX,
   parseServerMessage,
   readDaemonToken
-} from "./chunk-5LVPB3ET.js";
+} from "./chunk-2LQITRTR.js";
 
 // src/client.ts
 import WebSocket from "ws";

package/dist/cli/{chunk-UWANRALT.js → chunk-QCEVJMXI.js}

@@ -1,7 +1,7 @@
 import {
   cleanTopic,
   sessionTitle
-} from "./chunk-5LVPB3ET.js";
+} from "./chunk-2LQITRTR.js";
 
 // src/daemon/crossSession.ts
 var FIRST_LINE = /^Another Claude session sent a message:\s*\n/;
@@ -356,9 +356,10 @@ function reduceEvent(s, ev) {
     case "PanePrompt": {
       const incoming = pendingFor(ev);
       const moved = s.pending?.source === "hook" && s.pending.kind === "question" && incoming.kind === "question" && !sameQuestion(incoming.text, s.pending.text);
-      if (s.pending?.source === "hook" && !moved) return s;
+      const bare = s.pending?.source === "hook" && s.pending.kind === "permission" && !s.pending.tool;
+      if (s.pending?.source === "hook" && !moved && !bare) return s;
       if (!moved && hooksReportPrompts(s) && lastHookAt && Date.parse(at) - Date.parse(lastHookAt) < HOOK_PRIORITY_MS) return s;
-      let pending = moved ? { ...incoming, ...s.pending.helperId ? { helperId: s.pending.helperId } : {} } : mergePending(s.pending, incoming);
+      let pending = moved ? { ...incoming, ...s.pending.helperId ? { helperId: s.pending.helperId } : {} } : bare ? incoming : mergePending(s.pending, incoming);
       if (pending.kind === "plan" && !pending.body && s.tool === "codex" && s.lastReply) pending = { ...pending, body: s.lastReply.text };
       if (s.pending && samePending(s.pending, pending)) return s;
       const state = pending.kind === "question" ? "waiting_input" : "waiting_permission";

package/dist/cli/{chunk-QBJEUZYW.js → chunk-R5462SQM.js}

@@ -17,7 +17,7 @@ function ledgeDir() {
 }
 function paths() {
   const dir = ledgeDir();
-  return { dir, tmuxConf: join(dir, "tmux.conf"), journal: join(dir, "sessions.json"), log: join(dir, "daemon.log"), pid: join(dir, "daemon.pid"), history: join(dir, "history"), machines: join(dir, "machines.json"), projects: join(dir, "projects.json"), island: join(dir, "island.json"), token: join(dir, "token"), mobile: join(dir, "mobile.json"), mobileSession: join(dir, "mobile-session.json"), mobileKey: join(dir, "mobile-key"), devices: join(dir, "devices.json") };
+  return { dir, tmuxConf: join(dir, "tmux.conf"), journal: join(dir, "sessions.json"), log: join(dir, "daemon.log"), pid: join(dir, "daemon.pid"), history: join(dir, "history"), machines: join(dir, "machines.json"), projects: join(dir, "projects.json"), island: join(dir, "island.json"), token: join(dir, "token"), mobile: join(dir, "mobile.json"), mobileSession: join(dir, "mobile-session.json"), mobileKey: join(dir, "mobile-key"), devices: join(dir, "devices.json"), revocations: join(dir, "revocations.json") };
 }
 async function ensureLedgeDir() {
   const p = paths();

package/dist/cli/{chunk-6A7JPTHV.js → chunk-ZANOMSLW.js}

@@ -1,13 +1,13 @@
 import {
   run
-} from "./chunk-FPW7MF5X.js";
+} from "./chunk-2H5FJH4Q.js";
 import {
   ensureLedgeDir,
   paths
-} from "./chunk-QBJEUZYW.js";
+} from "./chunk-R5462SQM.js";
 
 // src/cli/setup.ts
-import { readFile as readFile2, writeFile, mkdir, rename, realpath, rm, stat, lstat, readlink, symlink, unlink } from "fs/promises";
+import { readFile as readFile2, writeFile, mkdir, rename, realpath, rm, stat, lstat, readlink } from "fs/promises";
 import { execFile } from "child_process";
 import { homedir, userInfo } from "os";
 import { join, dirname } from "path";
@@ -237,14 +237,23 @@ async function isDir(path) {
     return false;
   }
 }
-async function relinkBin(opts) {
+var BIN_MARK = "#!/bin/sh\n# Written by `ledge setup`";
+var shQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+async function writeBin(opts) {
   const st = await lstat(opts.link).catch(() => null);
-  if (!st?.isSymbolicLink()) return null;
-  const current = await readlink(opts.link);
-  if (current === opts.target || !current.endsWith("/dist/cli/index.js")) return null;
-  await unlink(opts.link);
-  await symlink(opts.target, opts.link);
-  return `${opts.link} now points to ${opts.target} (was ${current})`;
+  if (!st) return null;
+  const was = st.isSymbolicLink() ? await readlink(opts.link) : null;
+  if (was !== null && !was.endsWith("/dist/cli/index.js")) return null;
+  const current = was === null && st.isFile() ? await readFile2(opts.link, "utf8").catch(() => "") : "";
+  if (was === null && !current.startsWith(BIN_MARK)) return null;
+  const script = `${BIN_MARK}: the hooks run \`ledge\` wherever node is not on the PATH.
+exec ${shQuote(opts.node)} ${shQuote(opts.target)} "$@"
+`;
+  if (current === script) return null;
+  const tmp = `${opts.link}.tmp`;
+  await writeFile(tmp, script, { mode: 493 });
+  await rename(tmp, opts.link);
+  return `${opts.link} runs ${opts.target} with ${opts.node}${was !== null ? ` (was a link to ${was})` : ""}`;
 }
 async function runSetup(opts = {}) {
   const out = [];
@@ -263,7 +272,7 @@ async function runSetup(opts = {}) {
   else if (await mergeJsonFile(join(cursorDir, "hooks.json"), mergeCursorHooks, "hooks.json")) out.push(`Cursor Agent hooks added in ${join(cursorDir, "hooks.json")}`);
   else out.push("Cursor Agent hooks already present");
   if ((opts.service ?? true) && !process.argv[1]?.endsWith(".ts")) {
-    const line = await relinkBin({ link: join(homedir(), ".local", "bin", "ledge"), target: await realpath(process.argv[1]) });
+    const line = await writeBin({ link: join(homedir(), ".local", "bin", "ledge"), node: process.execPath, target: await realpath(process.argv[1]) });
     if (line) out.push(line);
   }
   if (opts.service ?? true) {
@@ -286,7 +295,8 @@ export {
   stopDetachedDaemon,
   installService,
   isDir,
-  relinkBin,
+  BIN_MARK,
+  writeBin,
   runSetup,
   inDaemonService,
   tmuxServerAtRisk