@paigy/mcp 0.40.1 → 0.40.3

package/dist/{chunk-4UZAPBKK.js → chunk-6QQHTUKJ.js}

@@ -2,7 +2,7 @@
 import { createRequire as __sdkCreateRequire } from "module";
 import { createHash, randomUUID } from "crypto";
 import { randomUUID as randomUUID3 } from "crypto";
-import { setTimeout as sleep3 } from "timers/promises";
+import { setTimeout as sleep2 } from "timers/promises";
 import { z as z3 } from "zod";
 import { z as z2 } from "zod";
 import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
@@ -14,6 +14,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statS
 import { homedir } from "os";
 import { join } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
+import { WebSocket } from "undici";
 var require2 = __sdkCreateRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3551,7 +3552,22 @@ function mcpInputSchema(s) {
 }
 var StartContactSchema = z.object({
   goalIds: z.tuple([z.string().uuid()]),
-  ask: z.string().trim().min(1).max(1e4),
+  // THE ASK IS THE QUESTION, not a bulletin with a question at the end (2026-09-16).
+  //
+  // A DecisionNeed is settled only by an answer in the shape THIS ask declares. Bundle news,
+  // findings and a decision into one, and the person answers whichever part engaged them —
+  // which settles nothing, leaves the need open, and gets them asked again. On call 619c5a92
+  // one ask carried a briefing, a side question ("the ring should show the agent's name now —
+  // what did you actually see?") and a one-of-four about how far an erase reaches. The owner
+  // answered the side question. The need stayed open; the card asked again. Of the 45 call
+  // asks carrying a decision, 27 are over 600 characters.
+  //
+  // Sending them separately costs nothing, because a CALL contact joins the call already
+  // happening (`goal/store.ts`, JOIN BEFORE MINTING) — several contacts on one Goal arrive as
+  // one call, planned as its turns, and each keeps its own settleable need.
+  ask: z.string().trim().min(1).max(1e4).describe(
+    "The question, and only what is needed to answer it. News, progress and findings are their own contact \u2014 a call contact JOINS a call already happening, so several arrive as one call. Do not bundle: a DecisionNeed is settled only by an answer in the shape this ask declares, so someone who answers the part that interested them settles nothing and is asked again."
+  ),
   waiting: z.enum(["none", "hard"]).default("none"),
   channel: z.enum(["notification", "call"]).default("notification"),
   options: z.array(z.object({ label: z.string().trim().min(1).max(1e3), image: z.string().url().optional(), html: z.string().max(16384).optional() }).strict()).min(2).max(6).optional(),
@@ -3563,12 +3579,25 @@ var CONTACT_DESCRIPTION = "Contact the user about exactly one existing Goal: pas
 var CreateGoalSchema = z2.object({
   outcome: z2.string().trim().min(1).max(1e4),
   ownerParticipant: z2.string().trim().min(1).optional(),
-  idempotencyKey: z2.string().trim().min(1).max(200)
+  idempotencyKey: z2.string().trim().min(1).max(200),
+  /** A past conversation this Goal should be read against — History's "new session from this"
+   *  (owner, on the call of 2026-09-14: "let's do the reference with the threading"). A
+   *  reference only: the owner reads it through `get_thread`, which does its own scoping, and
+   *  the writer refuses a thread belonging to another account. */
+  contextThreadId: z2.string().uuid().optional(),
+  /** THE GOAL THIS ONE BELONGS UNDER (owner, 2026-09-15: "the ask I gave for the design doc
+   *  didn't get created as a child goal of the voice UI goal, which is how it should've
+   *  worked"). It could not have been: this door took no parent, so the only route was
+   *  create -> claim -> `update_goal`, three calls with a lease in the middle, and every agent
+   *  took the short one. The hierarchy has been modelled since Goals existed and had been used
+   *  ZERO times in 2,031 of them. Absent, the server judges it against the caller's open Goals
+   *  (`apps/api/src/goal/intake.ts`). The writer refuses a Goal belonging to another account. */
+  parentGoalId: z2.string().uuid().optional()
 });
 var CreateGoalToolSchema = CreateGoalSchema.extend({
   idempotencyKey: CreateGoalSchema.shape.idempotencyKey.optional().describe("Optional. One is minted per call; pass your own only so a retry lands on the same Goal.")
 }).strict();
-var CREATE_GOAL_DESCRIPTION = "Create a durable root Goal for an outcome. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
+var CREATE_GOAL_DESCRIPTION = "Create a durable Goal for an outcome. Without parentGoalId it is placed against your open Goals: if one already IS this work, that Goal comes back (existing: true) and nothing new is created \u2014 continue it; if the work belongs under one, it is created there (parentGoalId in the receipt); otherwise it is a root. Pass parentGoalId yourself to put it under a specific Goal. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
 var UpdateGoalSchema = z2.object({
   revision: z2.number().int().positive(),
   changes: z2.object({
@@ -3896,16 +3925,6 @@ function deriveAsk(req) {
 }
 var NotifyStatusSchema = z3.enum(["pending", "answered", "ignored"]);
 var AgentStateSchema = z3.enum(["idle", "in_progress", "completed", "needs_input"]);
-var SetTaskStateSchema = z3.object({
-  state: z3.enum(["in_progress", "completed", "needs_input"])
-});
-var SetWorkStateSchema = z3.object({
-  workId: z3.string().uuid().optional(),
-  notificationId: z3.string().optional(),
-  state: SetTaskStateSchema.shape.state
-}).refine((value) => Number(Boolean(value.workId)) + Number(Boolean(value.notificationId)) === 1, {
-  message: "exactly one of workId or notificationId is required"
-});
 var TurnSchema = z3.object({
   prompt: z3.string(),
   reply: z3.string()
@@ -4035,108 +4054,6 @@ var AwaitItemSchema = z3.discriminatedUnion("type", [
   })
 ]);
 var CallbackTriggerSchema = z3.enum(["on_done", "on_blocked", "scheduled"]);
-var ScheduleCallbackSchema = z3.object({
-  parentId: z3.string().describe("The thread to call back on (from a prior contact / reply / request)."),
-  goalId: z3.string().uuid().optional().describe("The Goal this callback advances; preferred for Goal-owned work."),
-  trigger: CallbackTriggerSchema,
-  dueInSeconds: z3.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
-  note: z3.string().optional().describe("What to tell the user when you follow up.")
-});
-var PendingRepliesSchema = z3.object({
-  replies: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      notificationId: z3.string(),
-      workId: z3.string().uuid().optional(),
-      decisionId: z3.string().uuid().optional(),
-      answer: UserAnswerSchema,
-      /** E2EE: the sealed answer (opaque envelope + plaintext `ignored` hint) when the
-       *  pairing is E2EE — the agent opens it and re-derives the real answer. Absent =
-       *  plaintext answer (in `answer`). See AwaitItemSchema's reply variant. */
-      sealed: z3.lazy(() => SealedAnswerSchema).optional(),
-      /** The call record rendered for THIS agent: the raw words the shaped answer was
-       *  mapped from, filtered to its own claims. See AwaitItemSchema's reply variant. */
-      transcript: z3.string().optional(),
-      /** Coverage report (#396): which declared `points` this answer addressed. */
-      covered: z3.array(z3.string()).optional()
-    })
-  ),
-  pending: z3.array(
-    z3.object({ parentId: z3.string(), notificationId: z3.string(), createdAt: z3.string() })
-  ),
-  /** WHO YOU ARE on this account (field report 2026-08-28): the name and device the user
-   *  sees for this session's identity. From inside a session there was no way to find out —
-   *  `pair` with no arguments can HATCH a fresh identity, so it is not a safe probe — and an
-   *  agent that cannot tell which agent it is cannot tell whether work addressed to
-   *  "Reta" was addressed to it. Absent only for a token with no pairing behind it. */
-  you: z3.object({ name: z3.string(), device: z3.string().nullable(), tokenId: z3.string() }).optional(),
-  /** User-initiated requests addressed to this agent; act on them and reply via
-   *  contact on the same parentId. Keeps reappearing until you call
-   *  set_work_state on its workId (or notificationId once while bootstrapping). */
-  requests: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      notificationId: z3.string(),
-      workId: z3.string().uuid().optional(),
-      text: z3.string(),
-      createdAt: z3.string(),
-      /** The user seeded this request with a past conversation — call get_thread on it
-       *  FIRST and treat the transcript as prior context (#57/#251). */
-      contextParentId: z3.string().optional(),
-      /** STRANDED (field report 2026-08-28): this request was addressed to ANOTHER agent on
-       *  the account — the name here — which has not been seen since it landed, so nobody
-       *  came for it. Handed to you because you are the session that is here. Take it like
-       *  any request (set_work_state claims it, reply with contact on its parentId), and say
-       *  whose it was, because the user chose that agent on purpose. */
-      stranded: z3.string().optional()
-    })
-  ),
-  /** Durable outcomes currently owned by this agent. This is the Work-native queue; flat
-   * notification lists remain during migration so old clients keep their existing view. */
-  work: z3.array(z3.object({
-    workId: z3.string().uuid(),
-    parentId: z3.string().optional(),
-    objective: z3.string().nullable(),
-    state: z3.enum(["active", "blocked", "waiting_external"]),
-    blockedOn: z3.array(z3.string().uuid()),
-    updatedAt: z3.string()
-  })).optional(),
-  /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,
-   *  if blocked, or at a time that has passed). Re-surfaced every sweep until you
-   *  fulfill one by calling contact on its parentId. */
-  /** Ride-alongs (RideAlongSchema): notes assigned to this agent that no wake could
-   *  reach. Same array the contact/await replies carry — one queue, every carrier. */
-  also: z3.array(RideAlongSchema).optional(),
-  owedCallbacks: z3.array(
-    z3.object({ parentId: z3.string(), trigger: CallbackTriggerSchema, note: z3.string() })
-  ),
-  /** Work (either direction) you reported in_progress a while ago and never reported
-   *  completed — likely left half-done by this session or a prior one that crashed or
-   *  went idle. Report a real state (set_work_state) or continue the work. */
-  stalled: z3.array(
-    z3.object({ parentId: z3.string(), notificationId: z3.string(), title: z3.string().nullable(), startedAt: z3.string() })
-  ),
-  /** The queue rail (#614, pending/design.md): the same replies + requests, grouped by
-   *  thread and ordered oldest-thread-first, so you work ONE thread at a time — fold all of
-   *  a thread's `items` into a single turn rather than interleaving threads. `busy` = the
-   *  thread already has a turn in progress (younger than the stall cutoff); let it finish and
-   *  ride the next turn. `items` are that thread's replies/requests in arrival order; the
-   *  full payload for each is in the flat `replies`/`requests` arrays (matched by
-   *  notificationId). Derived, never stored — a crashed agent recomputes it exactly. */
-  threads: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      busy: z3.boolean(),
-      items: z3.array(
-        z3.object({
-          kind: z3.enum(["reply", "request"]),
-          notificationId: z3.string(),
-          at: z3.string()
-        })
-      )
-    })
-  )
-});
 var NotifyResponseSchema = z3.object({
   notificationId: z3.string(),
   workId: z3.string().uuid().optional(),
@@ -4364,7 +4281,21 @@ var InboxItemSchema = z3.object({
   /** E2EE: the agent's device X25519 public key to seal the user's answer BACK to (the
    *  sender the phone replies to). Sourced server-side from this item's pairing credential.
    *  Present only alongside `envelope`; the phone seals via sealAnswer(answer, this, id). */
-  agentX25519: z3.string().optional()
+  agentX25519: z3.string().optional(),
+  /** THE TARGET FACTS A CARD RENDERS (#1796 point 5, 2026-09-11): the Delivery it is a view of,
+   *  that Delivery's kind, the request Entry, the Goals it answers for, the exact DecisionNeed (none
+   *  for a request that asks nothing), whether its content is sealed, and that Goal's state. The
+   *  answer writer (`POST /api/entries`) and the disposition (`close_delivery`) take their ids from
+   *  here. The server projects it (`apps/api/src/inbox/project.ts`); a client never builds it. */
+  communication: z3.object({
+    deliveryId: z3.string(),
+    kind: z3.enum(["notification", "call"]),
+    entryId: z3.string(),
+    goalIds: z3.array(z3.string()),
+    decisionNeedId: z3.string().optional(),
+    sealed: z3.boolean(),
+    goalState: z3.string().optional()
+  }).optional()
 });
 var SnoozeRequestSchema = z3.object({
   requestId: z3.string(),
@@ -4600,26 +4531,54 @@ var CreateRequestSchema = z3.object({
    *  the agent reads it via get_thread. Must belong to the requesting user. */
   contextParentId: z3.string().optional()
 });
-var HandoffSchema = z3.object({
-  /** Move this existing outcome to `target` without reminting it. Requires `target`. */
-  workId: z3.string().uuid().optional(),
-  /** Land the note on an existing thread; omitted mints a fresh one. */
-  parentId: z3.string().uuid().optional(),
-  /** One-line headline of the working context handed off. */
-  title: z3.string().min(1),
-  /** The brief — standalone notes the successor reads (what was done, what's left, links). */
-  notes: z3.array(z3.string().min(1)).min(1),
-  /** A sibling connection to dispatch directly to (token id or agent nickname). Same-account
-   *  only; omit to leave the thread for the user to hand off in the app. */
-  target: z3.string().optional(),
-  /** Write the note as a RECAP (kind:'recap', #617): a summary turn that supersedes the
-   *  thread's earlier turns for rehydration — get_thread returns the latest recap + only
-   *  the turns after it. Handoff-to-a-successor and handoff-to-yourself-later are the
-   *  same primitive; a recap is one whose audience includes you. */
-  recap: z3.boolean().optional()
-}).refine((value) => !value.workId || Boolean(value.target), {
-  message: "target is required when handing off Work",
-  path: ["target"]
+var QueueQuestionSchema = z3.object({
+  /** The decision need's id — what an answer is accepted against. */
+  id: z3.string(),
+  /** The words that were asked, from the request Entry that asked them. */
+  question: z3.string(),
+  /** Where it was asked — which is where the ruling goes (`POST /api/entries`). Null only
+   *  for a need whose request Entry is carried by no interactive Delivery, which nothing
+   *  can answer. */
+  deliveryId: z3.string().nullable().default(null),
+  /** The Entry the ruling is about. */
+  aboutId: z3.string().nullable().default(null),
+  /** Empty for a free-text question. */
+  options: z3.array(OptionSchema).default([]),
+  select: z3.enum(["one", "many", "rank", "confirm", "text"]).default("text"),
+  askedAt: z3.string(),
+  /** Null while the question is open — which is how the page tells the two apart. */
+  answeredAt: z3.string().nullable().default(null),
+  /** The ruling in the person's own words, from the contribution that replied — not the
+   *  option id, which is not something anyone reads back. Null while it is open, and null
+   *  for a settled question whose reply carried nothing readable. */
+  answer: z3.string().nullable().default(null)
+});
+var QueueItemSchema = z3.object({
+  id: z3.string(),
+  /** One-line headline — the first sentence of the outcome. */
+  title: z3.string(),
+  /** The outcome in full, verbatim: the person's own words are what an assignee sees. */
+  intent: z3.string(),
+  /** `ready` | `active` | `waiting` | `done` | `cancelled`, straight off the Goal. */
+  state: z3.string(),
+  /** Who holds it (a participant ref); null when nobody does yet. */
+  assignee: z3.string().nullable().default(null),
+  /** What the agent last said it was doing; null if it has said nothing. */
+  progress: z3.string().nullable().default(null),
+  reviewPending: z3.boolean().default(false),
+  dueAt: z3.string().nullable().default(null),
+  /** The Goal this one was opened under; null at the root. */
+  parentGoalId: z3.string().nullable().default(null),
+  /** Goals opened under this one — only those the same list holds. */
+  childGoalIds: z3.array(z3.string()).default([]),
+  /** Goals this one waits on (start or finish gates). */
+  dependencyGoalIds: z3.array(z3.string()).default([]),
+  /** True while any gate is on a Goal that is not done — the walk draws it dashed. */
+  blocked: z3.boolean().default(false),
+  /** Every decision need on it, open or settled — the page decides which to show. */
+  questions: z3.array(QueueQuestionSchema).default([]),
+  createdAt: z3.string(),
+  updatedAt: z3.string().nullable().default(null)
 });
 var NoteSourceSchema = z3.enum(["app", "call"]);
 var NoteStatusSchema = z3.enum(["open", "assigned", "in_progress", "done"]);
@@ -4748,6 +4707,8 @@ var AcceptTriageResultSchema = z3.object({
   failed: z3.array(z3.object({ noteId: z3.string(), reason: z3.string() }))
 });
 var DeliveryModeSchema = z3.enum(["poll", "self_hosted"]);
+var WAKE_EVENT = "wake";
+var wakeChannel = (tokenId) => `wake:${tokenId}`;
 var RegisterDeliverySchema = z3.object({ mode: DeliveryModeSchema });
 var OAuthStartSchema = z3.object({
   provider: z3.enum(["cma"]),
@@ -4756,8 +4717,9 @@ var OAuthStartSchema = z3.object({
 var DeliveryConfigSchema = z3.object({
   tokenId: z3.string(),
   mode: DeliveryModeSchema,
-  /** null when the server has no SUPABASE_ANON_KEY set — the listener then falls
-   *  back to its own PAIGY_SUPABASE_URL / PAIGY_SUPABASE_ANON_KEY env. */
+  /** null when the deployment has no anon key configured. `self_hosted` is then REFUSED
+   *  (503 `self_hosted_unavailable`) rather than registered, so a self_hosted config always
+   *  carries credentials; only a `poll` registration can come back with null here. */
   realtime: z3.object({ url: z3.string(), anonKey: z3.string() }).nullable()
 });
 var StatusSchema = z3.object({
@@ -4966,21 +4928,6 @@ function utf8ToBytes(s) {
   }
   return Uint8Array.from(out);
 }
-function bytesToUtf8(b) {
-  let out = "";
-  for (let i = 0; i < b.length; ) {
-    const c = b[i++];
-    if (c < 128) out += String.fromCharCode(c);
-    else if (c < 224) out += String.fromCharCode((c & 31) << 6 | b[i++] & 63);
-    else if (c < 240) out += String.fromCharCode((c & 15) << 12 | (b[i++] & 63) << 6 | b[i++] & 63);
-    else {
-      const cp = (c & 7) << 18 | (b[i++] & 63) << 12 | (b[i++] & 63) << 6 | b[i++] & 63;
-      const u = cp - 65536;
-      out += String.fromCharCode(55296 + (u >> 10), 56320 + (u & 1023));
-    }
-  }
-  return out;
-}
 var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 function toB64(bytes) {
   let out = "";
@@ -5026,15 +4973,9 @@ function concat(parts) {
   }
   return out;
 }
-function u16be(n) {
-  return Uint8Array.of(n >>> 8 & 255, n & 255);
-}
 function u32be(n) {
   return Uint8Array.of(n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255);
 }
-function readU32be(b, o) {
-  return (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>> 0;
-}
 function lp(b) {
   return concat([u32be(b.length), b]);
 }
@@ -5076,9 +5017,6 @@ function sharedSecret(peerX25519PubB64, mySecretB64) {
   if (raw.every((b) => b === 0)) throw new Error("low-order X25519 point \u2014 shared secret rejected");
   return toB64(raw);
 }
-function keyId(publicKeyB64) {
-  return toB64(import_tweetnacl2.default.hash(fromB64(publicKeyB64)).slice(0, 8));
-}
 function credentialBody(c) {
   return concat([
     lp(utf8ToBytes("paigy-device-credential-v1")),
@@ -5096,43 +5034,6 @@ function verifyDeviceCredential(cred, uikPublicB64) {
     return false;
   }
 }
-var ENVELOPE_VERSION = 1;
-var ENVELOPE_ALG = "x25519-xsalsa20poly1305";
-function canonicalHeader(msgId, hdr) {
-  const parts = [
-    u16be(ENVELOPE_VERSION),
-    lp(utf8ToBytes(ENVELOPE_ALG)),
-    lp(msgId),
-    lp(utf8ToBytes(hdr.field)),
-    lp(utf8ToBytes(hdr.kind)),
-    lp(utf8ToBytes(hdr.senderRole)),
-    u32be(hdr.seq),
-    u32be(hdr.recipientKeyIds.length),
-    ...hdr.recipientKeyIds.map((k) => lp(utf8ToBytes(k)))
-  ];
-  return concat(parts);
-}
-function open(envelope, myKeyId, mySecretKeyB64) {
-  if (envelope.v !== ENVELOPE_VERSION) throw new Error(`unsupported envelope version ${String(envelope.v)}`);
-  if (envelope.alg !== ENVELOPE_ALG) throw new Error(`unsupported alg ${String(envelope.alg)}`);
-  const rec = envelope.recipients.find((r) => r.keyId === myKeyId);
-  if (!rec) throw new Error("not a recipient of this envelope");
-  const cek = import_tweetnacl3.default.box.open(fromB64(rec.wrap), fromB64(rec.wnonce), fromB64(rec.epk), fromB64(mySecretKeyB64));
-  if (!cek) throw new Error("CEK unwrap failed (wrong key or tampered)");
-  const padded = import_tweetnacl3.default.secretbox.open(fromB64(envelope.ct), fromB64(envelope.nonce), cek);
-  if (!padded) throw new Error("body authentication failed (tampered ciphertext)");
-  if (padded.length < 8) throw new Error("malformed sealed plaintext");
-  const canonLen = readU32be(padded, 0);
-  if (canonLen < 0 || 8 + canonLen > padded.length) throw new Error("malformed sealed plaintext");
-  const sealedCanon = padded.slice(4, 4 + canonLen);
-  const bodyLen = readU32be(padded, 4 + canonLen);
-  const bodyStart = 8 + canonLen;
-  if (bodyStart + bodyLen > padded.length) throw new Error("malformed sealed plaintext");
-  const body = padded.slice(bodyStart, bodyStart + bodyLen);
-  const expected = canonicalHeader(fromB64(envelope.msgId), envelope.hdr);
-  if (!eqCt(sealedCanon, expected)) throw new Error("header mismatch (tampered metadata)");
-  return { header: envelope.hdr, body };
-}
 var SAS_DOMAIN = "paigy-sas-v2";
 function deriveSAS(input, bits = 24) {
   const bundle = concat([
@@ -5360,21 +5261,6 @@ async function pairStep(deviceCode, keyFile) {
     return { kind: "e2ee_aborted", warning: e.message };
   }
 }
-function openSealedAnswer(sealed, keypair) {
-  const myKeyId = keyId(keypair.x25519.publicKey);
-  const { header, body } = open(sealed.envelope, myKeyId, keypair.x25519.secretKey);
-  if (header.field !== "answer" || header.senderRole !== "user") {
-    throw new Error("sealed answer has the wrong envelope field/role \u2014 refusing (possible replay/misattribution)");
-  }
-  const parsed = UserAnswerSchema.safeParse(JSON.parse(bytesToUtf8(body)));
-  if (!parsed.success) throw new Error("sealed answer body is not a valid UserAnswer");
-  const answer = parsed.data;
-  const bodyIsIgnored = answer.kind === "ignored";
-  if (sealed.ignored !== bodyIsIgnored) {
-    throw new Error("sealed answer tamper: `ignored` hint disagrees with the decrypted body");
-  }
-  return answer;
-}
 var UnpairedError = class extends Error {
   constructor() {
     super("Not paired with Paigy \u2014 no valid token (the API answered 401). Run the pairing flow, then retry.");
@@ -5435,6 +5321,7 @@ async function updateGoal(goalId, input, opts = {}) {
   if (!res.ok) await fail("update_goal", res);
   return await res.json();
 }
+var AWAIT_WINDOW_MS = 45e3;
 async function getThread(parentId, opts = {}) {
   const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/thread/${encodeURIComponent(parentId)}`, {
     headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}`, "x-paigy-model": "goal-entry-v1" }
@@ -5449,17 +5336,6 @@ async function searchThreads(q, opts = {}) {
   if (!res.ok) await fail("search_threads", res);
   return await res.json();
 }
-async function sweepLeased(opts = {}) {
-  const token = authToken(opts.token);
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
-    headers: {
-      authorization: `Bearer ${token}`,
-      "x-paigy-await-ack": "1"
-    }
-  }));
-  if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
 var tokenOverride = null;
 function overrideToken(secret) {
   tokenOverride = secret;
@@ -5505,10 +5381,10 @@ async function heartbeat(runtime, opts = {}) {
   }));
   if (!res.ok) throw new Error(`heartbeat failed: ${res.status}`);
 }
-async function registerDelivery(mode) {
+async function registerDelivery(mode, opts = {}) {
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
     method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${authToken()}` },
+    headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     body: JSON.stringify({ mode })
   }));
   if (!res.ok) throw new Error(`register_delivery failed: ${res.status} ${await res.text()}`);
@@ -5544,7 +5420,7 @@ Inbox delivery is asynchronous; use claim_goal/get_goal to collect durable answe
   };
   const settled = (d) => d.kind === "notification" || d.state === "closed" || d.answers.length > 0 || d.entries.some((e) => e.kind === "contribution");
   if (opts.waits === false) return read(opts.signal);
-  const window = AbortSignal.timeout(45e3);
+  const window = AbortSignal.timeout(AWAIT_WINDOW_MS);
   const signal = opts.signal ? AbortSignal.any([opts.signal, window]) : window;
   let latest;
   try {
@@ -5552,7 +5428,7 @@ Inbox delivery is asynchronous; use claim_goal/get_goal to collect durable answe
       signal.throwIfAborted();
       latest = await read(signal);
       if (settled(latest)) return latest;
-      await sleep3(5e3, void 0, { signal });
+      await sleep2(5e3, void 0, { signal });
     }
   } catch (error) {
     opts.signal?.throwIfAborted();
@@ -5604,106 +5480,102 @@ async function runTool(name, args, opts) {
       throw new Error(`Unknown tool: ${name}`);
   }
 }
-var sleep4 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var ReplyLeaseExpiredError = class extends Error {
-  constructor() {
-    super(
-      "The Paigy reply lease expired before acknowledgement. The answer remains durable; wait on it again (contact with only { wait: notificationId }) to reclaim it before acting."
-    );
-    this.name = "ReplyLeaseExpiredError";
-  }
-};
-var ReplyAckError = class extends Error {
-  constructor(message, retryable) {
-    super(message);
-    this.retryable = retryable;
-    this.name = "ReplyAckError";
-  }
-  retryable;
-};
-function decryptAnswer(reply, deps = {}) {
-  if (!reply.sealed) return reply.answer;
-  const keyFile = (deps.readKeyFile ?? readKeyFile)();
-  if (!keyFile?.keypair) {
-    throw new Error(
-      "received a sealed answer but this agent has no device key to open it \u2014 re-pair."
-    );
-  }
-  return openSealedAnswer(reply.sealed, keyFile.keypair);
-}
-function decodeReply(item, deps = {}) {
-  const { delivery: _delivery, ...withoutDelivery } = item;
-  const enriched = { ...withoutDelivery };
-  if (!enriched.sealed) return enriched;
-  const answer = decryptAnswer(enriched, deps);
-  const { sealed: _sealed, ...plaintext } = enriched;
-  return { ...plaintext, answer };
-}
-function deliveryOf(item) {
-  if (item.type !== "reply" || !("delivery" in item) || item.delivery === void 0) {
-    return null;
-  }
-  const delivery = item.delivery;
-  if (!delivery || typeof delivery.leaseId !== "string" || !delivery.leaseId || typeof delivery.expiresAt !== "string" || !delivery.expiresAt) {
-    throw new Error(
-      "Paigy returned invalid reply-delivery metadata; the answer was not acknowledged and remains recoverable."
-    );
-  }
-  return delivery;
-}
-async function responseDetail(res) {
+var HEARTBEAT_MS = 25e3;
+var RETRY_MS = [1e3, 2e3, 5e3, 1e4, 3e4];
+var JOIN = { config: { broadcast: { self: false } } };
+var lines = /* @__PURE__ */ new Map();
+function frame(line, topic, event, payload) {
   try {
-    return (await res.text()).slice(0, 300);
+    line.ws?.send(JSON.stringify({ topic, event, payload, ref: String(++line.ref) }));
   } catch {
-    return "";
   }
 }
-async function acknowledge(token, leaseId, opts = {}) {
-  const attempts = Math.max(1, Math.min(opts.attempts ?? 3, 5));
-  const backoffMs = Math.max(0, opts.backoffMs ?? 100);
-  const doSleep = opts.doSleep ?? sleep4;
-  let lastError;
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
+function stop(line) {
+  line.open = false;
+  clearInterval(line.heart);
+  clearTimeout(line.retry);
+}
+function connect(line) {
+  const base = line.url.replace(/^http/, "ws").replace(/\/+$/, "");
+  const ws = line.ws = new WebSocket(`${base}/realtime/v1/websocket?apikey=${encodeURIComponent(line.anonKey)}&vsn=1.0.0`);
+  ws.addEventListener("open", () => {
+    line.open = true;
+    line.attempt = 0;
+    for (const topic of line.topics.keys()) frame(line, `realtime:${topic}`, "phx_join", JOIN);
+    line.heart = setInterval(() => frame(line, "phoenix", "heartbeat", {}), HEARTBEAT_MS);
+  });
+  ws.addEventListener("message", (e) => {
+    let m;
     try {
-      const res = ensureAuthed(await reach(`${BACKEND_URL}/api/await/ack`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify({ leaseId })
-      }));
-      if (res.ok) return;
-      const detail2 = await responseDetail(res);
-      if (res.status === 409) throw new ReplyLeaseExpiredError();
-      const retryable = res.status === 408 || res.status === 425 || res.status === 429 || res.status >= 500;
-      throw new ReplyAckError(
-        `Paigy reply acknowledgement failed: ${res.status}${detail2 ? ` ${detail2}` : ""}`,
-        retryable
-      );
-    } catch (error) {
-      if (error instanceof UnpairedError || error instanceof ReplyLeaseExpiredError || error instanceof ReplyAckError && !error.retryable) {
-        throw error;
+      m = JSON.parse(String(e.data));
+    } catch {
+      return;
+    }
+    if (m.event !== "broadcast" || !m.topic?.startsWith("realtime:")) return;
+    for (const l of line.topics.get(m.topic.slice("realtime:".length)) ?? []) {
+      if (m.payload?.event === l.event) l.onMessage(m.payload.payload);
+    }
+  });
+  let gone = false;
+  const again = () => {
+    if (gone) return;
+    gone = true;
+    stop(line);
+    if (!line.topics.size) return;
+    line.retry = setTimeout(() => connect(line), RETRY_MS[Math.min(line.attempt++, RETRY_MS.length - 1)]);
+  };
+  ws.addEventListener("close", again);
+  ws.addEventListener("error", again);
+}
+function subscribeRealtime(args) {
+  const key = `${args.url} ${args.anonKey}`;
+  let line = lines.get(key);
+  if (!line) lines.set(key, line = { url: args.url, anonKey: args.anonKey, open: false, attempt: 0, ref: 0, topics: /* @__PURE__ */ new Map() });
+  let heard = line.topics.get(args.topic);
+  if (!heard) {
+    line.topics.set(args.topic, heard = /* @__PURE__ */ new Set());
+    if (line.open) frame(line, `realtime:${args.topic}`, "phx_join", JOIN);
+  }
+  const me = { event: args.event, onMessage: args.onMessage };
+  heard.add(me);
+  if (!line.ws) connect(line);
+  return {
+    close: () => {
+      if (!heard.delete(me) || heard.size) return;
+      line.topics.delete(args.topic);
+      if (line.topics.size) {
+        if (line.open) frame(line, `realtime:${args.topic}`, "phx_leave", {});
+        return;
       }
-      lastError = error;
-      if (attempt + 1 < attempts) {
-        await doSleep(backoffMs * 2 ** attempt);
+      lines.delete(key);
+      stop(line);
+      try {
+        line.ws?.close();
+      } catch {
       }
     }
-  }
-  const detail = lastError instanceof Error ? lastError.message : String(lastError);
-  throw new Error(
-    `Could not acknowledge the Paigy reply after ${attempts} attempts (${detail}). The answer was not returned to the agent and remains recoverable after the lease expires.`
-  );
+  };
 }
-async function ackReply(item, token, opts = {}) {
-  const delivery = deliveryOf(item);
-  if (!delivery) throw new Error("Paigy returned a reply without a delivery lease; nothing to acknowledge.");
-  await acknowledge(token, delivery.leaseId, {
-    attempts: opts.ackAttempts,
-    backoffMs: opts.ackBackoffMs,
-    doSleep: opts.ackSleep
+async function subscribeWake(onNudge, opts = {}) {
+  const cfg = await registerDelivery("self_hosted", opts);
+  const { url, anonKey } = cfg.realtime;
+  const channel = wakeChannel(cfg.tokenId);
+  const ch = subscribeRealtime({
+    url,
+    anonKey,
+    topic: channel,
+    event: WAKE_EVENT,
+    onMessage: (payload) => onNudge(payload ?? {})
   });
+  return {
+    tokenId: cfg.tokenId,
+    channel,
+    close: async () => {
+      ch.close();
+      await registerDelivery("poll", opts).catch(() => {
+      });
+    }
+  };
 }
 
 export {
@@ -5729,15 +5601,13 @@ export {
   fetchCredential,
   pairStep,
   UnpairedError,
-  sweepLeased,
+  getGoal,
   overrideToken,
-  authToken,
   hatch,
   whoAmI,
   setIdentity,
   heartbeat,
-  registerDelivery,
+  checkReplies,
   runTool,
-  decodeReply,
-  ackReply
+  subscribeWake
 };