@paigy/mcp 0.25.2 → 0.26.0

package/dist/{chunk-2374V6WK.js → chunk-B7SCZUYX.js}

@@ -2277,7 +2277,7 @@ async function reach(url, init) {
 var TITLE_MAX = 90;
 var CHUNKS_MAX = 8;
 var CHUNK_MAX = 300;
-var ASK_MAX = 1e3;
+var ASK_MAX = 1e4;
 var OPTION_MAX = 80;
 var NEEDS_MAX = 6;
 var UNSPEAKABLE = /```|\n/;
@@ -2438,8 +2438,13 @@ var NotifyRequestSchema = z.object({
    *  matters now — the broker derives the optimal shape and channel. Mutually
    *  exclusive with `context` (and never sent alongside `envelope`: E2EE pairings
    *  derive agent-side before sealing, so the server only ever shapes plaintext). */
-  ask: z.string().min(1).optional().describe(
-    'SIMPLIFIED FORM \u2014 state in plain prose what you need to learn from the user and why it matters now (e.g. "I need to know whether to deploy the auth fix \u2014 tests are green, staging verified"). Paigy derives the title, answer shape, options, and delivery channel for you. Mutually exclusive with context/select/options \u2014 send one form or the other.'
+  // 10k, not a sentence budget. What the human hears is bounded by the BROKER — it splits
+  // the ask into topics and gives each one at most three sentences and one question
+  // (broker/agenda-design.md) — not by a wire cap the agent has to pre-summarize under.
+  // Owner, 2026-07-28: "our actual limitation on how long something is to the user should
+  // come from the broker splitting and summarizing." The cap that remains is a size guard.
+  ask: z.string().min(1).max(1e4).optional().describe(
+    'SIMPLIFIED FORM \u2014 state in plain prose what you need to learn from the user and why it matters now (e.g. "I need to know whether to deploy the auth fix \u2014 tests are green, staging verified"). Write as much as the situation needs (up to 10k characters) \u2014 Paigy breaks it into topics and reads it back a few sentences at a time; do NOT pre-summarize it into one line. Paigy derives the title, answer shape, options, and delivery channel for you. Mutually exclusive with context/select/options \u2014 send one form or the other.'
   ),
   needs: z.array(z.string().min(1)).optional().describe(
     "With `ask` only: the distinct things you need answered when the ask is multi-part \u2014 becomes the coverage contract (`points`), so a half-answer is never silently final."
@@ -2512,6 +2517,23 @@ function normalizeWaiting(req) {
     blocking: req.blocking || waiting === "hard"
   };
 }
+var DERIVE_CHUNKS_MAX = 8;
+var DERIVE_CHUNK_MAX = 300;
+function chunkAsk(text, max = DERIVE_CHUNK_MAX, cap = DERIVE_CHUNKS_MAX) {
+  const body = text.trim();
+  if (!body) return [];
+  const sentences = body.match(/[^.!?]+[.!?]*\s*/g) ?? [body];
+  const chunks = [];
+  for (const raw of sentences) {
+    const s = raw.trim();
+    if (!s) continue;
+    const last = chunks[chunks.length - 1];
+    if (last !== void 0 && `${last} ${s}`.length <= max) chunks[chunks.length - 1] = `${last} ${s}`;
+    else chunks.push(s);
+  }
+  if (chunks.length <= cap) return chunks;
+  return [...chunks.slice(0, cap - 1), chunks.slice(cap - 1).join(" ")];
+}
 function deriveAsk(req) {
   req = normalizeWaiting(req);
   if (!req.ask) return req;
@@ -2523,7 +2545,7 @@ function deriveAsk(req) {
   const { ask: _ask, needs, urgencyHint: _hint, channel: _channel, ...rest } = req;
   return {
     ...rest,
-    context: { title, description: [text] },
+    context: { title, description: chunkAsk(text) },
     // Options riding alongside the ask (#575: pixels can't be prose) floor to a
     // single pick — the model broker may upgrade to many/rank from the wording.
     select: req.options?.length ? "one" : "text",
@@ -2598,6 +2620,22 @@ var AwaitItemSchema = z.discriminatedUnion("type", [
     threadId: z.string(),
     notificationId: z.string()
   }),
+  /** A LIVE call's turn, streamed as it lands (#783). PROVISIONAL: the user can still
+   *  revise any of these until the final reply arrives — partial = intelligence,
+   *  settled = authorization. Use it to PREPARE (fetch, draft, warm), never to act
+   *  irreversibly. If `acts` carries a question aimed at you and you know the answer,
+   *  contact on the same thread right away — the caller hears it on the same call. */
+  z.object({
+    type: z.literal("partial"),
+    notificationId: z.string(),
+    inFlight: z.literal(true),
+    turn: z.object({
+      idx: z.number(),
+      prompt: z.string(),
+      reply: z.string(),
+      acts: z.array(IntentSchema).nullable().optional()
+    })
+  }),
   z.object({ type: z.literal("idle") })
 ]);
 var CallbackTriggerSchema = z.enum(["on_done", "on_blocked", "scheduled"]);
@@ -2698,6 +2736,16 @@ var UserResponseSchema = z.object({
   covered: z.array(z.string()).optional()
 });
 var VoiceKeySchema = z.enum(["rachel", "george", "jessica", "brian", "lily"]);
+var AgendaTurnSchema = z.object({
+  /** At most three short spoken sentences. Capped because a turn is a breath: a 1031-char
+   *  line went out on 2026-07-28 and the caller could not answer it at all. */
+  info: z.array(z.string().min(1)).max(3).default([]),
+  question: z.string().min(1).nullable(),
+  /** True on the one turn carrying the agent's own declared question. */
+  asks: z.boolean().optional(),
+  select: SelectShapeSchema.optional(),
+  options: z.array(OptionSchema.omit({ id: true })).optional()
+});
 var InboxItemSchema = z.object({
   id: z.string(),
   /** The conversation thread + connection this item lives on. Present on the replied
@@ -2709,9 +2757,11 @@ var InboxItemSchema = z.object({
   options: z.array(OptionSchema).optional(),
   /** The ask's declared coverage points (#396), when the agent sent them. */
   points: z.array(z.string()).optional(),
-  /** Natural spoken questions for the points (#417 follow-up), phrased at ring time
-   *  and index-aligned — the call bot prefers these over the raw shorthand. */
-  pointsSpeak: z.array(z.string()).optional(),
+  /** The call's AGENDA (broker/agenda-design.md): the ordered turns it is made of, built at
+   *  ring/enqueue time. Replaces the condensed line + index-aligned phrased points, which
+   *  between them could not express a call as a sequence. `question: null` is a real turn —
+   *  a status update stays a statement instead of being shaped into a yes/no. */
+  agenda: z.array(AgendaTurnSchema).optional(),
   /** On a replied detail (#397): the next steps the user attached to the answer
    *  ("call back after lunch") — shown so they can see the commitment was captured. */
   intents: z.array(IntentSchema).optional(),
@@ -2812,7 +2862,6 @@ var UserSettingsSchema = z.object({
   /** Per-user ring budget (#603): calls per rolling day before further calls
    *  degrade to banner. Absent = the global default (25). A number, never a
    *  bypass — every account keeps a ceiling. No UI; set per user for testing. */
-  callBudget: z.number().int().min(1).max(500).optional(),
   /** Per-user voice-call tuning (#318): raw knobs forwarded to the call bot's
    *  payload['tuning'] (e.g. { silence_s: 3.5 } — a longer pause window for a
    *  slower speaker). No API-side semantics; the bot resolves each key with its
@@ -2894,6 +2943,49 @@ var HandoffSchema = z.object({
    *  same primitive; a recap is one whose audience includes you. */
   recap: z.boolean().optional()
 });
+var NoteSourceSchema = z.enum(["app", "call"]);
+var NoteStatusSchema = z.enum(["open", "assigned", "done"]);
+var DecisionSchema = z.object({
+  id: z.string(),
+  /** The note this decision refines; null = recorded on a bare thread (the
+   *  extensibility seam — any conversation can accrue decisions). */
+  noteId: z.string().nullable(),
+  /** What was ambiguous — the broker's (or the user's own) question. */
+  question: z.string(),
+  /** The user's ruling; null while the question is open. */
+  answer: z.string().nullable(),
+  decidedAt: z.string().nullable(),
+  createdAt: z.string()
+});
+var NoteSchema = z.object({
+  id: z.string(),
+  /** One-line headline (broker-titled; deterministic floor). */
+  title: z.string(),
+  /** The original intent, verbatim — assignees always see the user's own words. */
+  intent: z.string(),
+  source: NoteSourceSchema,
+  status: NoteStatusSchema,
+  /** Who it was assigned to (a participant ref, 'agent:<tokenId>'); null = unassigned. */
+  assignee: z.string().nullable(),
+  /** The request thread minted at assignment; null until assigned. */
+  threadId: z.string().nullable(),
+  createdAt: z.string()
+});
+var CreateNoteSchema = z.object({
+  /** The intent, in the user's own words. Stored verbatim; the broker only titles it. */
+  text: z.string().min(1).max(4e3)
+});
+var RecordDecisionSchema = z.object({
+  /** An open decision (from /clarify) to answer. */
+  decisionId: z.string().optional(),
+  /** For an ad-hoc decision: what was ambiguous. Required without `decisionId`. */
+  question: z.string().min(1).max(500).optional(),
+  /** The ruling. */
+  answer: z.string().min(1).max(2e3)
+}).refine((d) => d.decisionId || d.question, { message: "decisionId or question required" });
+var AssignNoteSchema = z.object({
+  target: z.string().min(1)
+});
 var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
 var RegisterDeliverySchema = z.object({ mode: DeliveryModeSchema });
 var OAuthStartSchema = z.object({
@@ -3043,6 +3135,8 @@ var NotificationFeedbackKindSchema = z.enum([
   // "These recommended answers aren't good — give me new ones."
   "needs_visual",
   // "There should be a picture or design here."
+  "should_have_called",
+  // "Don't put this in a banner — ring me for something like this."
   "other"
   // anything else — the note carries it.
 ]);
@@ -3645,6 +3739,25 @@ async function pollAnswer(notificationId) {
   const item = await res.json();
   return item.type === "idle" ? item : decryptItem(item);
 }
+var _partialSeen = /* @__PURE__ */ new Map();
+async function pollPartials(notificationId) {
+  const token = readToken();
+  const after = _partialSeen.get(notificationId) ?? 0;
+  try {
+    const res = await reach(
+      `${BACKEND_URL}/api/await/partials?notificationId=${encodeURIComponent(notificationId)}&afterIdx=${after}`,
+      { headers: { authorization: `Bearer ${token}` } }
+    );
+    if (!res.ok) return null;
+    const body = await res.json();
+    const next = body.turns?.[0];
+    if (!next) return null;
+    _partialSeen.set(notificationId, next.idx);
+    return { type: "partial", notificationId, inFlight: true, turn: next };
+  } catch {
+    return null;
+  }
+}
 async function awaitReply(notificationId, opts = {}) {
   const intervalMs = opts.intervalMs ?? 5e3;
   const windowMs = opts.windowMs ?? 3e5;
@@ -3654,6 +3767,8 @@ async function awaitReply(notificationId, opts = {}) {
   while (true) {
     const item = await pollAnswer(notificationId);
     if (item.type !== "idle") return item;
+    const partial = await pollPartials(notificationId);
+    if (partial) return partial;
     if (now() - start >= windowMs) return { type: "idle" };
     await doSleep(intervalMs);
   }

package/dist/{chunk-FEAIZ6DA.js → chunk-BZPE2ZFE.js}

@@ -1,6 +1,6 @@
 import {
   AGENT_NAME
-} from "./chunk-2374V6WK.js";
+} from "./chunk-B7SCZUYX.js";
 
 // src/clients.ts
 import { execFile } from "child_process";

package/dist/{chunk-LUY5MXDM.js → chunk-KAEJRPN5.js}

@@ -122,8 +122,13 @@ var NotifyRequestSchema = z.object({
    *  matters now — the broker derives the optimal shape and channel. Mutually
    *  exclusive with `context` (and never sent alongside `envelope`: E2EE pairings
    *  derive agent-side before sealing, so the server only ever shapes plaintext). */
-  ask: z.string().min(1).optional().describe(
-    'SIMPLIFIED FORM \u2014 state in plain prose what you need to learn from the user and why it matters now (e.g. "I need to know whether to deploy the auth fix \u2014 tests are green, staging verified"). Paigy derives the title, answer shape, options, and delivery channel for you. Mutually exclusive with context/select/options \u2014 send one form or the other.'
+  // 10k, not a sentence budget. What the human hears is bounded by the BROKER — it splits
+  // the ask into topics and gives each one at most three sentences and one question
+  // (broker/agenda-design.md) — not by a wire cap the agent has to pre-summarize under.
+  // Owner, 2026-07-28: "our actual limitation on how long something is to the user should
+  // come from the broker splitting and summarizing." The cap that remains is a size guard.
+  ask: z.string().min(1).max(1e4).optional().describe(
+    'SIMPLIFIED FORM \u2014 state in plain prose what you need to learn from the user and why it matters now (e.g. "I need to know whether to deploy the auth fix \u2014 tests are green, staging verified"). Write as much as the situation needs (up to 10k characters) \u2014 Paigy breaks it into topics and reads it back a few sentences at a time; do NOT pre-summarize it into one line. Paigy derives the title, answer shape, options, and delivery channel for you. Mutually exclusive with context/select/options \u2014 send one form or the other.'
   ),
   needs: z.array(z.string().min(1)).optional().describe(
     "With `ask` only: the distinct things you need answered when the ask is multi-part \u2014 becomes the coverage contract (`points`), so a half-answer is never silently final."
@@ -254,6 +259,22 @@ var AwaitItemSchema = z.discriminatedUnion("type", [
     threadId: z.string(),
     notificationId: z.string()
   }),
+  /** A LIVE call's turn, streamed as it lands (#783). PROVISIONAL: the user can still
+   *  revise any of these until the final reply arrives — partial = intelligence,
+   *  settled = authorization. Use it to PREPARE (fetch, draft, warm), never to act
+   *  irreversibly. If `acts` carries a question aimed at you and you know the answer,
+   *  contact on the same thread right away — the caller hears it on the same call. */
+  z.object({
+    type: z.literal("partial"),
+    notificationId: z.string(),
+    inFlight: z.literal(true),
+    turn: z.object({
+      idx: z.number(),
+      prompt: z.string(),
+      reply: z.string(),
+      acts: z.array(IntentSchema).nullable().optional()
+    })
+  }),
   z.object({ type: z.literal("idle") })
 ]);
 var CallbackTriggerSchema = z.enum(["on_done", "on_blocked", "scheduled"]);
@@ -354,6 +375,16 @@ var UserResponseSchema = z.object({
   covered: z.array(z.string()).optional()
 });
 var VoiceKeySchema = z.enum(["rachel", "george", "jessica", "brian", "lily"]);
+var AgendaTurnSchema = z.object({
+  /** At most three short spoken sentences. Capped because a turn is a breath: a 1031-char
+   *  line went out on 2026-07-28 and the caller could not answer it at all. */
+  info: z.array(z.string().min(1)).max(3).default([]),
+  question: z.string().min(1).nullable(),
+  /** True on the one turn carrying the agent's own declared question. */
+  asks: z.boolean().optional(),
+  select: SelectShapeSchema.optional(),
+  options: z.array(OptionSchema.omit({ id: true })).optional()
+});
 var InboxItemSchema = z.object({
   id: z.string(),
   /** The conversation thread + connection this item lives on. Present on the replied
@@ -365,9 +396,11 @@ var InboxItemSchema = z.object({
   options: z.array(OptionSchema).optional(),
   /** The ask's declared coverage points (#396), when the agent sent them. */
   points: z.array(z.string()).optional(),
-  /** Natural spoken questions for the points (#417 follow-up), phrased at ring time
-   *  and index-aligned — the call bot prefers these over the raw shorthand. */
-  pointsSpeak: z.array(z.string()).optional(),
+  /** The call's AGENDA (broker/agenda-design.md): the ordered turns it is made of, built at
+   *  ring/enqueue time. Replaces the condensed line + index-aligned phrased points, which
+   *  between them could not express a call as a sequence. `question: null` is a real turn —
+   *  a status update stays a statement instead of being shaped into a yes/no. */
+  agenda: z.array(AgendaTurnSchema).optional(),
   /** On a replied detail (#397): the next steps the user attached to the answer
    *  ("call back after lunch") — shown so they can see the commitment was captured. */
   intents: z.array(IntentSchema).optional(),
@@ -468,7 +501,6 @@ var UserSettingsSchema = z.object({
   /** Per-user ring budget (#603): calls per rolling day before further calls
    *  degrade to banner. Absent = the global default (25). A number, never a
    *  bypass — every account keeps a ceiling. No UI; set per user for testing. */
-  callBudget: z.number().int().min(1).max(500).optional(),
   /** Per-user voice-call tuning (#318): raw knobs forwarded to the call bot's
    *  payload['tuning'] (e.g. { silence_s: 3.5 } — a longer pause window for a
    *  slower speaker). No API-side semantics; the bot resolves each key with its
@@ -550,6 +582,49 @@ var HandoffSchema = z.object({
    *  same primitive; a recap is one whose audience includes you. */
   recap: z.boolean().optional()
 });
+var NoteSourceSchema = z.enum(["app", "call"]);
+var NoteStatusSchema = z.enum(["open", "assigned", "done"]);
+var DecisionSchema = z.object({
+  id: z.string(),
+  /** The note this decision refines; null = recorded on a bare thread (the
+   *  extensibility seam — any conversation can accrue decisions). */
+  noteId: z.string().nullable(),
+  /** What was ambiguous — the broker's (or the user's own) question. */
+  question: z.string(),
+  /** The user's ruling; null while the question is open. */
+  answer: z.string().nullable(),
+  decidedAt: z.string().nullable(),
+  createdAt: z.string()
+});
+var NoteSchema = z.object({
+  id: z.string(),
+  /** One-line headline (broker-titled; deterministic floor). */
+  title: z.string(),
+  /** The original intent, verbatim — assignees always see the user's own words. */
+  intent: z.string(),
+  source: NoteSourceSchema,
+  status: NoteStatusSchema,
+  /** Who it was assigned to (a participant ref, 'agent:<tokenId>'); null = unassigned. */
+  assignee: z.string().nullable(),
+  /** The request thread minted at assignment; null until assigned. */
+  threadId: z.string().nullable(),
+  createdAt: z.string()
+});
+var CreateNoteSchema = z.object({
+  /** The intent, in the user's own words. Stored verbatim; the broker only titles it. */
+  text: z.string().min(1).max(4e3)
+});
+var RecordDecisionSchema = z.object({
+  /** An open decision (from /clarify) to answer. */
+  decisionId: z.string().optional(),
+  /** For an ad-hoc decision: what was ambiguous. Required without `decisionId`. */
+  question: z.string().min(1).max(500).optional(),
+  /** The ruling. */
+  answer: z.string().min(1).max(2e3)
+}).refine((d) => d.decisionId || d.question, { message: "decisionId or question required" });
+var AssignNoteSchema = z.object({
+  target: z.string().min(1)
+});
 var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
 var WAKE_EVENT = "wake";
 var wakeChannel = (tokenId) => `wake:${tokenId}`;
@@ -701,6 +776,8 @@ var NotificationFeedbackKindSchema = z.enum([
   // "These recommended answers aren't good — give me new ones."
   "needs_visual",
   // "There should be a picture or design here."
+  "should_have_called",
+  // "Don't put this in a banner — ring me for something like this."
   "other"
   // anything else — the note carries it.
 ]);

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   HandoffSchema
-} from "./chunk-LUY5MXDM.js";
+} from "./chunk-KAEJRPN5.js";
 import {
   PAIGY_TOOL_IDS,
   autoConfigureClients,
   claudeInstallHint,
   enablePaigyTools
-} from "./chunk-FEAIZ6DA.js";
+} from "./chunk-BZPE2ZFE.js";
 import {
   clearSurface,
   writeSurface
@@ -39,7 +39,7 @@ import {
   sleep,
   startE2ee,
   submitNotification
-} from "./chunk-2374V6WK.js";
+} from "./chunk-B7SCZUYX.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -83,7 +83,7 @@ var CONTACT_SCHEMA = {
   properties: {
     ask: {
       type: "string",
-      description: "What to tell the user, or what you need to find out from them. Plain prose, one or two sentences; may be spoken aloud on a call, so write natural speech and name things (not IDs)."
+      description: "What to tell the user, or what you need to find out from them. Plain prose \u2014 as long as it needs to be (up to 10k characters); Paigy splits it into topics and reads back a few sentences at a time, so do NOT compress a briefing into one line. May be spoken aloud on a call, so write natural speech and name things (not IDs)."
     },
     waiting: {
       type: "string",
@@ -381,7 +381,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     },
     {
       name: "await_reply",
-      description: "Wait for the user's reply to a specific notification you sent (pass the notificationId from contact). This is how you wait for your answer in-context. Polls ~5 min; returns { type:'reply', answer } when they respond, { type:'remind', remindInSeconds } on snooze (ScheduleWakeup then await_reply again), or { type:'idle' } (timed out this window, no answer yet). On idle, if this is genuinely still blocking you and you have nothing else useful to do meanwhile, just call await_reply again immediately \u2014 keep looping. This is how you actually deliver on the point of calling: the user steps away for a while and comes back to find you'd already continued the moment they answered, not idle waiting to be checked on. Don't give up after one window. Only stop looping to do other work (and check back later), or after an unreasonably long stretch (tens of minutes to hours) worth telling the user about instead. Scoped to that one notification \u2014 it NEVER returns replies meant for other notifications, so concurrent contact calls don't cross. A CALL answer can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction. Usually that's the only turn; if there are more (e.g. an end-of-call 'call me back when it's done / I have a blocking question'), read each one in order as a further follow-up instruction, not a single combined one. If they asked for a callback, re-engage in the SAME thread (contact with the reply's threadId) when the task is done or you hit a blocker \u2014 waiting:'hard' for a blocker, waiting:'none' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing). A call-mapped answer may carry `intents` \u2014 next steps the user attached, each { kind, detail } with detail quoting their words. ACT on them, don't just read them: 'defer' (\"call me after lunch\") \u2192 register it NOW with schedule_callback \u2014 when the intent carries `dueInSeconds` (Paigy pre-parsed the spoken time against the user's clock) pass it straight through; otherwise derive it from the detail yourself \u2014 then follow up on the same thread; 'delegate' (\"you pick\") \u2192 make the call yourself and tell them what you chose; 'channel' (\"text me next time\") \u2192 honor it on your next contact (channel:'message'); 'question' (an open question aimed back at you that the call couldn't answer) \u2192 you OWE them the answer \u2014 work it out and follow up on the same thread without being asked, the call deliberately skipped \"should I call you back?\" because the follow-up is implied. `transcript` is the user's raw words behind a shaped answer \u2014 read it for hedges and conditions (\"yes, IF tests pass\") before acting. If your ask declared `points`, the reply carries `covered` \u2014 the points actually addressed. Compare against what you declared: a missing point is STILL unanswered \u2014 re-ask it (contact on the same threadId) or proceed knowingly partial; never treat a partial answer as complete.",
+      description: "Wait for the user's reply to a specific notification you sent (pass the notificationId from contact). This is how you wait for your answer in-context. Polls ~5 min; returns { type:'reply', answer } when they respond, { type:'remind', remindInSeconds } on snooze (ScheduleWakeup then await_reply again), or { type:'idle' } (timed out this window, no answer yet). While your contact is being handled on a LIVE call, you may receive { type:'partial', inFlight:true, turn } results: what the user said to each turn, as they say it. Use partials to PREPARE \u2014 fetch the data, draft the thing, warm the build \u2014 never to act irreversibly: the user can still revise any of them until the final reply arrives. Partial = intelligence, settled = authorization. If a partial's acts carry a question aimed at you and you know the answer, call contact on the SAME threadId right away \u2014 the caller hears your answer on the same call instead of waiting for a callback. Keep calling await_reply until you get the final reply \u2014 THAT one is the decision. On idle, if this is genuinely still blocking you and you have nothing else useful to do meanwhile, just call await_reply again immediately \u2014 keep looping. This is how you actually deliver on the point of calling: the user steps away for a while and comes back to find you'd already continued the moment they answered, not idle waiting to be checked on. Don't give up after one window. Only stop looping to do other work (and check back later), or after an unreasonably long stretch (tens of minutes to hours) worth telling the user about instead. Scoped to that one notification \u2014 it NEVER returns replies meant for other notifications, so concurrent contact calls don't cross. A CALL answer can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction. Usually that's the only turn; if there are more (e.g. an end-of-call 'call me back when it's done / I have a blocking question'), read each one in order as a further follow-up instruction, not a single combined one. If they asked for a callback, re-engage in the SAME thread (contact with the reply's threadId) when the task is done or you hit a blocker \u2014 waiting:'hard' for a blocker, waiting:'none' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing). A call-mapped answer may carry `intents` \u2014 next steps the user attached, each { kind, detail } with detail quoting their words. ACT on them, don't just read them: 'defer' (\"call me after lunch\") \u2192 register it NOW with schedule_callback \u2014 when the intent carries `dueInSeconds` (Paigy pre-parsed the spoken time against the user's clock) pass it straight through; otherwise derive it from the detail yourself \u2014 then follow up on the same thread; 'delegate' (\"you pick\") \u2192 make the call yourself and tell them what you chose; 'channel' (\"text me next time\") \u2192 honor it on your next contact (channel:'message'); 'question' (an open question aimed back at you that the call couldn't answer) \u2192 you OWE them the answer \u2014 work it out and follow up on the same thread without being asked, the call deliberately skipped \"should I call you back?\" because the follow-up is implied. `transcript` is the user's raw words behind a shaped answer \u2014 read it for hedges and conditions (\"yes, IF tests pass\") before acting. If your ask declared `points`, the reply carries `covered` \u2014 the points actually addressed. Compare against what you declared: a missing point is STILL unanswered \u2014 re-ask it (contact on the same threadId) or proceed knowingly partial; never treat a partial answer as complete.",
       inputSchema: json(AwaitReplySchema)
     },
     {

package/dist/listen.js

@@ -2,11 +2,11 @@
 import {
   WAKE_EVENT,
   wakeChannel
-} from "./chunk-LUY5MXDM.js";
+} from "./chunk-KAEJRPN5.js";
 import {
   checkReplies,
   registerDelivery
-} from "./chunk-2374V6WK.js";
+} from "./chunk-B7SCZUYX.js";
 
 // src/listen.ts
 import { createClient } from "@supabase/supabase-js";

package/dist/onboard.js

@@ -3,7 +3,7 @@ import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-FEAIZ6DA.js";
+} from "./chunk-BZPE2ZFE.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -11,7 +11,7 @@ import {
   requestCode,
   saveToken,
   sleep
-} from "./chunk-2374V6WK.js";
+} from "./chunk-B7SCZUYX.js";
 
 // src/onboard.ts
 async function main() {

package/dist/statusline.js

@@ -6,7 +6,7 @@ import {
   BACKEND_URL,
   reach,
   readToken
-} from "./chunk-2374V6WK.js";
+} from "./chunk-B7SCZUYX.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.25.2",
+  "version": "0.26.0",
   "description": "Paigy MCP server — a voice inbox for your AI agents. Lets an agent notify a user and await their reply.",
   "license": "MIT",
   "type": "module",
@@ -36,9 +36,9 @@
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8",
-    "@paigy/crypto": "0.0.0",
+    "@paigy/sdk": "0.1.0",
     "@paigy/schema": "0.0.0",
-    "@paigy/sdk": "0.1.0"
+    "@paigy/crypto": "0.0.0"
   },
   "scripts": {
     "build": "tsup",