@paigy/mcp 0.40.1 → 0.40.3

package/dist/{chunk-CXABA27N.js → chunk-TNQOFCZC.js}

@@ -10,7 +10,7 @@ import {
   saveToken,
   sleep,
   startE2ee
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {

package/dist/{chunk-3QUIB42M.js → chunk-V3VVCML7.js}

@@ -36,7 +36,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(),
@@ -48,12 +63,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({
@@ -99,6 +127,21 @@ var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
 function serverInstructions(_opts) {
   return "On startup and after a wake, call check_replies for the open Deliveries addressed to you, and claim_goal for your runnable or review-pending Goal and its durable Entries and accepted decisions. get_goal rereads the same evidence without consuming it. Contact only for an existing Goal. Notifications return immediately: keep working and collect answers through claim_goal/get_goal. On stdio, Calls hold one bounded window; on hosted MCP, Calls return after one read; continue with contact({deliveryId}) to reread that exact Delivery. Evidence can repeat: reads do not acknowledge or hide it. Use update_goal to report progress and explicitly acknowledge review. Never infer ringing from an open Call Delivery. Soft waiting, multipart contact, and re-presentation are unsupported. In an interactive session, ask the user directly; use Paigy when they asked for it or are away.";
 }
+function entryWords(entry) {
+  const content = entry.content;
+  if (content && "sealed" in content) return "";
+  const plain = content?.plain;
+  if (typeof plain === "string") return plain;
+  if (plain && typeof plain === "object") {
+    const text = plain.text;
+    if (typeof text === "string") return text;
+    const title = plain.title;
+    const description = plain.description;
+    const parts = [title, ...Array.isArray(description) ? description : []].filter((v) => typeof v === "string");
+    if (parts.length) return parts.join("\n\n");
+  }
+  return entry.sources.map((source) => source.text).join("\n");
+}
 var ContextSchema = z3.object({
   title: z3.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
   description: z3.array(z3.string().min(1)).describe(
@@ -329,16 +372,6 @@ var NotifyRequestSchema = NotifyRequestFields.superRefine((r, ctx) => {
 });
 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()
@@ -468,108 +501,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(),
@@ -797,7 +728,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(),
@@ -1033,26 +978,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"]);
@@ -1181,8 +1154,6 @@ 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"]),
@@ -1191,8 +1162,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({
@@ -1383,6 +1355,5 @@ export {
   mcpInputSchema,
   AGENT_TOOLS,
   serverInstructions,
-  WAKE_EVENT,
-  wakeChannel
+  entryWords
 };

package/dist/enable.js

@@ -2,9 +2,9 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-TLASZUJD.js";
-import "./chunk-3QUIB42M.js";
-import "./chunk-4UZAPBKK.js";
+} from "./chunk-4JDG67EF.js";
+import "./chunk-V3VVCML7.js";
+import "./chunk-6QQHTUKJ.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-CXABA27N.js";
+} from "./chunk-TNQOFCZC.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -16,8 +16,8 @@ import {
   autoConfigureClients,
   claudeInstallHint,
   paigyToolsAllowlisted
-} from "./chunk-TLASZUJD.js";
-import "./chunk-3QUIB42M.js";
+} from "./chunk-4JDG67EF.js";
+import "./chunk-V3VVCML7.js";
 import {
   clearSurface,
   writeSurface
@@ -38,7 +38,7 @@ import {
   setIdentity,
   slotName,
   whoAmI
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";

package/dist/listen.js

@@ -1,18 +1,14 @@
 #!/usr/bin/env node
 import {
-  WAKE_EVENT,
-  wakeChannel
-} from "./chunk-3QUIB42M.js";
+  entryWords
+} from "./chunk-V3VVCML7.js";
 import {
-  ackReply,
-  authToken,
-  decodeReply,
-  registerDelivery,
-  sweepLeased
-} from "./chunk-4UZAPBKK.js";
+  checkReplies,
+  getGoal,
+  subscribeWake
+} from "./chunk-6QQHTUKJ.js";
 
 // src/listen.ts
-import { createClient } from "@supabase/supabase-js";
 import { spawn } from "child_process";
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
@@ -24,7 +20,7 @@ import { homedir } from "os";
 import { join } from "path";
 var LABEL = "ai.paigy.listen";
 function frozenEnv() {
-  const keys = ["PAIGY_BACKEND_URL", "PAIGY_ON_WAKE", "PAIGY_SUPABASE_URL", "PAIGY_SUPABASE_ANON_KEY"];
+  const keys = ["PAIGY_BACKEND_URL", "PAIGY_ON_WAKE"];
   return Object.fromEntries(keys.flatMap((k) => process.env[k] ? [[k, process.env[k]]] : []));
 }
 function renderLaunchd(nodePath, scriptPath, env) {
@@ -114,114 +110,49 @@ function uninstallService() {
   return unit;
 }
 
-// src/message.ts
-function answerText(answer) {
-  switch (answer.kind) {
-    case "text":
-      return answer.text;
-    case "option":
-      return answer.label ?? answer.optionId;
-    case "multi":
-    case "ranked":
-      return (answer.labels ?? answer.optionIds).join(", ");
-    case "confirm":
-      return answer.approved ? "approved" : "declined";
-    case "clarify":
-      return answer.chunks.join(" ");
-    case "turns":
-      return answer.turns.map((turn) => turn.reply).join(" ");
-    case "precedent":
-      return answer.answer;
-    case "ignored":
-      return "";
-  }
-}
-
 // src/listen.ts
 var emit = (obj) => void process.stdout.write(JSON.stringify(obj) + "\n");
-function launchEnv(work, reason) {
-  const env = { PAIGY_WORK: JSON.stringify(work), PAIGY_EVENT: reason };
+function saidIn(delivery) {
+  return delivery.entries.filter((entry) => entry.kind === "contribution").map((entry) => entryWords(entry)).filter(Boolean).join("\n");
+}
+function launchEnv(waiting, reason, goalId) {
+  const env = { PAIGY_WORK: JSON.stringify(waiting), PAIGY_EVENT: reason };
   const put = (key, value) => {
     if (value) env[key] = value;
   };
-  const lead = work.threads?.find((t) => !t.busy)?.items[0]?.notificationId;
-  const reply = lead ? work.replies.find((r) => r.notificationId === lead) : work.replies[0];
-  const request = lead ? work.requests.find((r) => r.notificationId === lead) : work.requests[0];
-  if (reply) {
-    put("PAIGY_THREAD_ID", reply.parentId);
-    put("PAIGY_PARENT_ID", reply.parentId);
-    put("PAIGY_NOTIFICATION_ID", reply.notificationId);
-    put("PAIGY_TEXT", answerText(reply.answer));
-    return env;
-  }
-  if (request) {
-    put("PAIGY_THREAD_ID", request.parentId);
-    put("PAIGY_PARENT_ID", request.parentId);
-    put("PAIGY_NOTIFICATION_ID", request.notificationId);
-    put("PAIGY_CONTEXT_THREAD_ID", request.contextParentId);
-    put("PAIGY_TEXT", request.text);
-    return env;
-  }
-  const callback = work.owedCallbacks[0];
-  if (callback) {
-    put("PAIGY_THREAD_ID", callback.parentId);
-    put("PAIGY_PARENT_ID", callback.parentId);
-    put("PAIGY_TEXT", callback.note);
-  }
+  const named = goalId ? waiting.deliveries.find((d) => d.goalIds.includes(goalId)) : void 0;
+  const lead = named ?? waiting.deliveries[0];
+  if (!lead) return env;
+  put("PAIGY_THREAD_ID", lead.threadId);
+  put("PAIGY_PARENT_ID", lead.threadId);
+  put("PAIGY_DELIVERY_ID", lead.deliveryId);
+  put("PAIGY_GOAL_ID", waiting.goal?.goalId ?? lead.goalIds[0]);
+  put("PAIGY_CONTEXT_THREAD_ID", waiting.goal?.contextThreadId);
+  put("PAIGY_TEXT", saidIn(lead) || lead.message);
   return env;
 }
-var SWEEP_PASSES = 10;
-async function sweep(reason) {
+async function sweep(reason, goalId) {
   try {
     const cmd = process.env.PAIGY_ON_WAKE;
-    const token = authToken() ?? "";
-    for (let pass = 0; pass < SWEEP_PASSES; pass += 1) {
-      const raw = await sweepLeased();
-      const leased = raw.replies;
-      const work = {
-        ...raw,
-        work: raw.work ?? [],
-        replies: leased.map((r) => {
-          const { type: _type, ...reply } = decodeReply({ ...r, type: "reply" });
-          return reply;
-        })
-      };
-      emit({ type: "sweep", reason, ...work });
-      const inbound = work.replies.length > 0 || work.requests.length > 0;
-      const reengage = work.owedCallbacks.length > 0 && (reason === "boot" || reason.includes("callback"));
-      if (cmd && (inbound || reengage)) {
-        spawn(cmd, { shell: true, stdio: "inherit", env: { ...process.env, ...launchEnv(work, reason) } });
-      }
-      if (cmd) for (const r of leased) await ackReply({ ...r, type: "reply" }, token);
-      if (leased.length === 0) return;
+    const { deliveries } = await checkReplies();
+    const lead = (goalId ? deliveries.find((d) => d.goalIds.includes(goalId)) : void 0) ?? deliveries[0];
+    const leadGoalId = lead?.goalIds[0];
+    const goal = leadGoalId ? await getGoal(leadGoalId).then((g) => ({ goalId: leadGoalId, contextThreadId: g.contextThreadId, progress: g.progress })).catch(() => null) : null;
+    const waiting = { deliveries, goal };
+    emit({ type: "sweep", reason, ...goalId ? { about: goalId } : {}, ...waiting });
+    if (cmd && deliveries.length) {
+      spawn(cmd, { shell: true, stdio: "inherit", env: { ...process.env, ...launchEnv(waiting, reason, goalId) } });
     }
   } catch (e) {
     emit({ type: "error", reason, message: e.message });
   }
 }
 async function main() {
-  const cfg = await registerDelivery("self_hosted");
-  const url = cfg.realtime?.url ?? process.env.PAIGY_SUPABASE_URL;
-  const anonKey = cfg.realtime?.anonKey ?? process.env.PAIGY_SUPABASE_ANON_KEY;
-  if (!url || !anonKey) {
-    throw new Error(
-      "No Realtime credentials \u2014 set SUPABASE_ANON_KEY on the server, or PAIGY_SUPABASE_URL + PAIGY_SUPABASE_ANON_KEY locally."
-    );
-  }
-  const channel = wakeChannel(cfg.tokenId);
-  emit({ type: "listening", channel });
+  const sub = await subscribeWake((nudge) => void sweep(`wake:${nudge.kind ?? "?"}`, nudge.parentId));
+  emit({ type: "listening", channel: sub.channel });
   await sweep("boot");
-  const sb = createClient(url, anonKey, { auth: { persistSession: false } });
-  sb.channel(channel).on(
-    "broadcast",
-    { event: WAKE_EVENT },
-    (msg) => void sweep(`wake:${msg.payload?.kind ?? "?"}`)
-  ).subscribe();
   const shutdown = async () => {
-    try {
-      await registerDelivery("poll");
-    } catch {
-    }
+    await sub.close();
     process.exit(0);
   };
   process.on("SIGINT", () => void shutdown());
@@ -251,5 +182,6 @@ if (isEntry()) {
 }
 export {
   launchEnv,
+  saidIn,
   sweep
 };

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-CXABA27N.js";
+} from "./chunk-TNQOFCZC.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-TLASZUJD.js";
-import "./chunk-3QUIB42M.js";
+} from "./chunk-4JDG67EF.js";
+import "./chunk-V3VVCML7.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/onboard.ts
 function reportRegistered() {

package/dist/slot.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   AGENT_NAME
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/slot.ts
 process.stdout.write(AGENT_NAME);

package/dist/statusline.js

@@ -9,7 +9,7 @@ import {
   readToken,
   sessionSlot,
   slotName
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.40.1",
+  "version": "0.40.3",
   "description": "Paigy MCP server — the AI agent harness that calls you. Lets an agent notify a user and await their reply.",
   "license": "MIT",
   "type": "module",
@@ -24,28 +24,28 @@
     "url": "git+https://github.com/mauurda/paigy.git",
     "directory": "apps/mcp"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm --filter @paigy/schema build && pnpm --filter @paigy/crypto build && pnpm --filter @paigy/sdk build && pnpm build"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
-    "@supabase/supabase-js": "^2.47.10",
     "qrcode-generator": "^2.0.4",
     "undici": "^6.27.0",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
+    "@paigy/crypto": "workspace:*",
+    "@paigy/schema": "workspace:*",
+    "@paigy/sdk": "workspace:*",
     "@types/node": "^22.0.0",
     "@types/qrcode-generator": "^1.0.6",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8",
-    "@paigy/crypto": "0.0.0",
-    "@paigy/schema": "0.0.0",
-    "@paigy/sdk": "0.2.1"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "vitest": "^2.1.8"
   }
-}
+}